//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.2
//
// <auto-generated>
//
// Generated from file `WpanAnalyzerRemoteControl.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//


#pragma warning disable 1591

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public abstract class WpanAnalyzerRemoteControlIdentity
                    {
                        public const string value = "Ellisys.AnalyzerRemoteControl.Wpan";
                    }

                    [global::System.Runtime.InteropServices.ComVisible(false)]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
                    public partial interface WpanAnalyzerRemoteControl : global::Ice.Object, WpanAnalyzerRemoteControlOperations_, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl
                    {
                    }
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys();

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public delegate void Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey();
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public interface WpanAnalyzerRemoteControlPrx : global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlPrx
                    {
                        void AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task AddThreadNetworkMasterKeyAsync(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey> begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_AddThreadNetworkMasterKey(global::Ice.AsyncResult asyncResult);

                        void RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveThreadNetworkAllMasterKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys> begin_RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveThreadNetworkAllMasterKeys(global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveThreadNetworkAllMasterKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveThreadNetworkMasterKeysAsync(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys> begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveThreadNetworkMasterKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveThreadNetworkMasterKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey> begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveThreadNetworkMasterKey(global::Ice.AsyncResult asyncResult);

                        void AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task AddZigbeeApsKeyAsync(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey> begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_AddZigbeeApsKey(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeApsAllKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys> begin_RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeApsAllKeys(global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeApsAllKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeApsKeysAsync(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys> begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeApsKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeApsKeyAsync(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey> begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeApsKey(global::Ice.AsyncResult asyncResult);

                        void AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task AddZigbeeNetworkKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey> begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_AddZigbeeNetworkKey(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeNetworkAllKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys> begin_RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkAllKeys(global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeNetworkAllKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeNetworkKeysAsync(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys> begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeNetworkKeys(global::Ice.AsyncResult asyncResult);

                        void RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::System.Threading.Tasks.Task RemoveZigbeeNetworkKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken());

                        global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey> begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie);

                        global::Ice.AsyncResult begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                        void end_RemoveZigbeeNetworkKey(global::Ice.AsyncResult asyncResult);
                    }
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public interface WpanAnalyzerRemoteControlOperations_ : global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlOperations_
                    {
                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveThreadNetworkAllMasterKeys(global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveThreadNetworkMasterKeys(int panId, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeApsAllKeys(global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeNetworkAllKeys(global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeNetworkKeys(int panId, global::Ice.Current current = null);

                        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                        void RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null);
                    }
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public sealed class ByteArrayHelper
                    {
                        public static void write(global::Ice.OutputStream ostr, byte[] v)
                        {
                            ostr.writeByteSeq(v);
                        }

                        public static byte[] read(global::Ice.InputStream istr)
                        {
                            byte[] v;
                            v = istr.readByteSeq();
                            return v;
                        }
                    }

                    [global::System.Runtime.InteropServices.ComVisible(false)]
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    [global::System.Serializable]
                    public sealed class WpanAnalyzerRemoteControlPrxHelper : global::Ice.ObjectPrxHelperBase, WpanAnalyzerRemoteControlPrx
                    {
                        public WpanAnalyzerRemoteControlPrxHelper()
                        {
                        }

                        public WpanAnalyzerRemoteControlPrxHelper(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context) : base(info, context)
                        {
                        }

                        #region Synchronous operations

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo GetAppInfo(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetAppInfoAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void ExitApp(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_ExitAppAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetAvailableDataSources(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetAvailableDataSourcesAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SelectDataSource(string dataSourceUniqueId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SelectDataSourceAsync(dataSourceUniqueId, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetSelectedDataSource(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetSelectedDataSourceAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public bool IsRecording(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_IsRecordingAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus GetRecordingStatus(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetRecordingStatusAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void StartRecording(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_StartRecordingAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_StopRecordingAndSaveTraceFileAsync(filename, overwrite, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AbortRecordingAndDiscardTraceFile(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AbortRecordingAndDiscardTraceFileAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetRecordingOptions(bool relevantOnly, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetRecordingOptionsAsync(relevantOnly, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void ConfigureRecordingOptions(string options, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_ConfigureRecordingOptionsAsync(options, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_InsertMessageAsync(severity, message, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public bool IsLoading(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_IsLoadingAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void StartLoading(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_StartLoadingAsync(filename, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo GetTraceFileInfo(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetTraceFileInfoAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void CloseTraceFile(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_CloseTraceFileAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public bool IsModified(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_IsModifiedAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SaveChanges(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SaveChangesAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AddMarkerOnSelectedOverviewItemAsync(marker, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AddMarkerAtTime(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AddMarkerAtTimeAsync(timeInPicoseconds, marker, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[] GetMarkers(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetMarkersAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void Export(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_ExportAsync(outputFilename, exportName, exportOptions, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetAvailableOverviews(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetAvailableOverviewsAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetSelectedOverview(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetSelectedOverviewAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SelectOverview(string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SelectOverviewAsync(overviewName, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetAvailableProtocolLayers(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetAvailableProtocolLayersAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetSelectedProtocolLayer(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetSelectedProtocolLayerAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SelectProtocolLayer(string protocolLayerName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SelectProtocolLayerAsync(protocolLayerName, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetOverviewQuery(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewQueryAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SetOverviewQuery(string query, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SetOverviewQueryAsync(query, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int OverviewRootItem(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_OverviewRootItemAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetOverviewItemDescription(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemDescriptionAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetOverviewItemsDescription(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemsDescriptionAsync(itemHandles, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public long GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemTimeInPicosecondsAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public long[] GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemsTimeInPicosecondsAsync(itemHandles, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public byte[] GetOverviewItemData(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemDataAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public byte[][] GetOverviewItemsData(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemsDataAsync(itemHandles, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetOverviewItemXmlReport(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemXmlReportAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemsXmlReportAsync(itemHandles, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemXmlReportFilteredAsync(itemHandle, fieldNameFilters, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public string[] GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemsXmlReportFilteredAsync(itemHandles, fieldNameFilters, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int GetOverviewItemChildCount(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemChildCountAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemChildAsync(itemHandle, childIndex, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int[] GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetOverviewItemChildrenAsync(itemHandle, childIndex, childCount, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int[] SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_SearchOverviewItemsAsync(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void ReleaseAllOverviewItemHandles(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_ReleaseAllOverviewItemHandlesAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void SelectOverviewItem(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_SelectOverviewItemAsync(itemHandle, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public int GetSelectedOverviewItem(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetSelectedOverviewItemAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void GetLogicSignalsState(long timeInPicoseconds, out int logicSignalsState, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                logicSignalsState = _iceI_GetLogicSignalsStateAsync(timeInPicoseconds, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, out int foundLogicSignalsState, out long foundTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                var result_ = _iceI_FindLogicSignalsTransitionAsync(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, context, null, global::System.Threading.CancellationToken.None, true).Result;
                                foundLogicSignalsState = result_.foundLogicSignalsState;
                                foundTimeInPicoseconds = result_.foundTimeInPicoseconds;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[] GetRunningTasks(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetRunningTasksAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AbortRunningTask(string name, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AbortRunningTaskAsync(name, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public byte[] GetSettings(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                return _iceI_GetSettingsAsync(context, null, global::System.Threading.CancellationToken.None, true).Result;
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void ConfigureSettings(byte[] settings, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_ConfigureSettingsAsync(settings, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void CancelUserInteraction(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_CancelUserInteractionAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void InsertComment(string comment, string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_InsertCommentAsync(comment, overviewName, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AddThreadNetworkMasterKeyAsync(panId, key128, sequenceCounter, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveThreadNetworkAllMasterKeysAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveThreadNetworkMasterKeysAsync(panId, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveThreadNetworkMasterKeyAsync(panId, key128, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AddZigbeeApsKeyAsync(destinationAddress64, sourceAddress64, key128, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeApsAllKeysAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeApsKeysAsync(destinationAddress64, sourceAddress64, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeApsKeyAsync(destinationAddress64, sourceAddress64, key128, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_AddZigbeeNetworkKeyAsync(panId, key128, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeNetworkAllKeysAsync(context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeNetworkKeysAsync(panId, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        public void RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            try
                            {
                                _iceI_RemoveZigbeeNetworkKeyAsync(panId, key128, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                            }
                            catch(global::System.AggregateException ex_)
                            {
                                throw ex_.InnerException;
                            }
                        }

                        #endregion

                        #region Async Task operations

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo> GetAppInfoAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetAppInfoAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo> _iceI_GetAppInfoAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetAppInfo_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo>(progress, cancel);
                            _iceI_GetAppInfo(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetAppInfo_name = "GetAppInfo";

                        private void _iceI_GetAppInfo(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo>(completed);
                            outAsync.invoke(
                                _GetAppInfo_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo ret = null;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo.ice_read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task ExitAppAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_ExitAppAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_ExitAppAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_ExitApp_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_ExitApp(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _ExitApp_name = "ExitApp";

                        private void _iceI_ExitApp(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _ExitApp_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetAvailableDataSourcesAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetAvailableDataSourcesAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetAvailableDataSourcesAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetAvailableDataSources_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetAvailableDataSources(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetAvailableDataSources_name = "GetAvailableDataSources";

                        private void _iceI_GetAvailableDataSources(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetAvailableDataSources_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task SelectDataSourceAsync(string dataSourceUniqueId, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SelectDataSourceAsync(dataSourceUniqueId, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SelectDataSourceAsync(string iceP_dataSourceUniqueId, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SelectDataSource_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SelectDataSource(iceP_dataSourceUniqueId, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SelectDataSource_name = "SelectDataSource";

                        private void _iceI_SelectDataSource(string iceP_dataSourceUniqueId, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SelectDataSource_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_dataSourceUniqueId);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetSelectedDataSourceAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetSelectedDataSourceAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetSelectedDataSourceAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetSelectedDataSource_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetSelectedDataSource(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetSelectedDataSource_name = "GetSelectedDataSource";

                        private void _iceI_GetSelectedDataSource(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetSelectedDataSource_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<bool> IsRecordingAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_IsRecordingAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<bool> _iceI_IsRecordingAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_IsRecording_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<bool>(progress, cancel);
                            _iceI_IsRecording(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _IsRecording_name = "IsRecording";

                        private void _iceI_IsRecording(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<bool>(completed);
                            outAsync.invoke(
                                _IsRecording_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    bool ret;
                                    ret = istr.readBool();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus> GetRecordingStatusAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetRecordingStatusAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus> _iceI_GetRecordingStatusAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetRecordingStatus_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus>(progress, cancel);
                            _iceI_GetRecordingStatus(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetRecordingStatus_name = "GetRecordingStatus";

                        private void _iceI_GetRecordingStatus(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus>(completed);
                            outAsync.invoke(
                                _GetRecordingStatus_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus ret = null;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus.ice_read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task StartRecordingAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_StartRecordingAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_StartRecordingAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_StartRecording_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_StartRecording(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _StartRecording_name = "StartRecording";

                        private void _iceI_StartRecording(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _StartRecording_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task StopRecordingAndSaveTraceFileAsync(string filename, bool overwrite, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_StopRecordingAndSaveTraceFileAsync(filename, overwrite, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_StopRecordingAndSaveTraceFileAsync(string iceP_filename, bool iceP_overwrite, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_StopRecordingAndSaveTraceFile_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_StopRecordingAndSaveTraceFile(iceP_filename, iceP_overwrite, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _StopRecordingAndSaveTraceFile_name = "StopRecordingAndSaveTraceFile";

                        private void _iceI_StopRecordingAndSaveTraceFile(string iceP_filename, bool iceP_overwrite, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _StopRecordingAndSaveTraceFile_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_filename);
                                    ostr.writeBool(iceP_overwrite);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task AbortRecordingAndDiscardTraceFileAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AbortRecordingAndDiscardTraceFileAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AbortRecordingAndDiscardTraceFileAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_AbortRecordingAndDiscardTraceFile_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AbortRecordingAndDiscardTraceFile(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AbortRecordingAndDiscardTraceFile_name = "AbortRecordingAndDiscardTraceFile";

                        private void _iceI_AbortRecordingAndDiscardTraceFile(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AbortRecordingAndDiscardTraceFile_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetRecordingOptionsAsync(bool relevantOnly, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetRecordingOptionsAsync(relevantOnly, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetRecordingOptionsAsync(bool iceP_relevantOnly, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetRecordingOptions_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetRecordingOptions(iceP_relevantOnly, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetRecordingOptions_name = "GetRecordingOptions";

                        private void _iceI_GetRecordingOptions(bool iceP_relevantOnly, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetRecordingOptions_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeBool(iceP_relevantOnly);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task ConfigureRecordingOptionsAsync(string options, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_ConfigureRecordingOptionsAsync(options, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_ConfigureRecordingOptionsAsync(string iceP_options, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_ConfigureRecordingOptions_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_ConfigureRecordingOptions(iceP_options, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _ConfigureRecordingOptions_name = "ConfigureRecordingOptions";

                        private void _iceI_ConfigureRecordingOptions(string iceP_options, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _ConfigureRecordingOptions_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_options);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task InsertMessageAsync(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_InsertMessageAsync(severity, message, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_InsertMessageAsync(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity iceP_severity, string iceP_message, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_InsertMessage_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_InsertMessage(iceP_severity, iceP_message, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _InsertMessage_name = "InsertMessage";

                        private void _iceI_InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity iceP_severity, string iceP_message, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _InsertMessage_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeEnum((int)iceP_severity, 3);
                                    ostr.writeString(iceP_message);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<bool> IsLoadingAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_IsLoadingAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<bool> _iceI_IsLoadingAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_IsLoading_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<bool>(progress, cancel);
                            _iceI_IsLoading(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _IsLoading_name = "IsLoading";

                        private void _iceI_IsLoading(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<bool>(completed);
                            outAsync.invoke(
                                _IsLoading_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    bool ret;
                                    ret = istr.readBool();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task StartLoadingAsync(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_StartLoadingAsync(filename, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_StartLoadingAsync(string iceP_filename, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_StartLoading_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_StartLoading(iceP_filename, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _StartLoading_name = "StartLoading";

                        private void _iceI_StartLoading(string iceP_filename, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _StartLoading_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_filename);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo> GetTraceFileInfoAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetTraceFileInfoAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo> _iceI_GetTraceFileInfoAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetTraceFileInfo_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo>(progress, cancel);
                            _iceI_GetTraceFileInfo(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetTraceFileInfo_name = "GetTraceFileInfo";

                        private void _iceI_GetTraceFileInfo(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo>(completed);
                            outAsync.invoke(
                                _GetTraceFileInfo_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo ret = null;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo.ice_read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task CloseTraceFileAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_CloseTraceFileAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_CloseTraceFileAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_CloseTraceFile_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_CloseTraceFile(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _CloseTraceFile_name = "CloseTraceFile";

                        private void _iceI_CloseTraceFile(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _CloseTraceFile_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<bool> IsModifiedAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_IsModifiedAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<bool> _iceI_IsModifiedAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_IsModified_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<bool>(progress, cancel);
                            _iceI_IsModified(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _IsModified_name = "IsModified";

                        private void _iceI_IsModified(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<bool>(completed);
                            outAsync.invoke(
                                _IsModified_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    bool ret;
                                    ret = istr.readBool();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task SaveChangesAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SaveChangesAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SaveChangesAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SaveChanges_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SaveChanges(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SaveChanges_name = "SaveChanges";

                        private void _iceI_SaveChanges(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SaveChanges_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task AddMarkerOnSelectedOverviewItemAsync(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AddMarkerOnSelectedOverviewItemAsync(marker, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AddMarkerOnSelectedOverviewItemAsync(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_AddMarkerOnSelectedOverviewItem_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AddMarkerOnSelectedOverviewItem(iceP_marker, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AddMarkerOnSelectedOverviewItem_name = "AddMarkerOnSelectedOverviewItem";

                        private void _iceI_AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AddMarkerOnSelectedOverviewItem_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker.ice_write(ostr, iceP_marker);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task AddMarkerAtTimeAsync(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AddMarkerAtTimeAsync(timeInPicoseconds, marker, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AddMarkerAtTimeAsync(long iceP_timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_AddMarkerAtTime_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AddMarkerAtTime(iceP_timeInPicoseconds, iceP_marker, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AddMarkerAtTime_name = "AddMarkerAtTime";

                        private void _iceI_AddMarkerAtTime(long iceP_timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AddMarkerAtTime_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeLong(iceP_timeInPicoseconds);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker.ice_write(ostr, iceP_marker);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]> GetMarkersAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetMarkersAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]> _iceI_GetMarkersAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetMarkers_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]>(progress, cancel);
                            _iceI_GetMarkers(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetMarkers_name = "GetMarkers";

                        private void _iceI_GetMarkers(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]>(completed);
                            outAsync.invoke(
                                _GetMarkers_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarkerArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task ExportAsync(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_ExportAsync(outputFilename, exportName, exportOptions, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_ExportAsync(string iceP_outputFilename, string iceP_exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] iceP_exportOptions, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_Export_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_Export(iceP_outputFilename, iceP_exportName, iceP_exportOptions, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _Export_name = "Export";

                        private void _iceI_Export(string iceP_outputFilename, string iceP_exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] iceP_exportOptions, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _Export_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_outputFilename);
                                    ostr.writeString(iceP_exportName);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOptionArrayHelper.write(ostr, iceP_exportOptions);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetAvailableOverviewsAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetAvailableOverviewsAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetAvailableOverviewsAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetAvailableOverviews_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetAvailableOverviews(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetAvailableOverviews_name = "GetAvailableOverviews";

                        private void _iceI_GetAvailableOverviews(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetAvailableOverviews_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetSelectedOverviewAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetSelectedOverviewAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetSelectedOverviewAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetSelectedOverview_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetSelectedOverview(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetSelectedOverview_name = "GetSelectedOverview";

                        private void _iceI_GetSelectedOverview(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetSelectedOverview_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task SelectOverviewAsync(string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SelectOverviewAsync(overviewName, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SelectOverviewAsync(string iceP_overviewName, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SelectOverview_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SelectOverview(iceP_overviewName, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SelectOverview_name = "SelectOverview";

                        private void _iceI_SelectOverview(string iceP_overviewName, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SelectOverview_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_overviewName);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetAvailableProtocolLayersAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetAvailableProtocolLayersAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetAvailableProtocolLayersAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetAvailableProtocolLayers_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetAvailableProtocolLayers(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetAvailableProtocolLayers_name = "GetAvailableProtocolLayers";

                        private void _iceI_GetAvailableProtocolLayers(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetAvailableProtocolLayers_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetSelectedProtocolLayerAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetSelectedProtocolLayerAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetSelectedProtocolLayerAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetSelectedProtocolLayer_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetSelectedProtocolLayer(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetSelectedProtocolLayer_name = "GetSelectedProtocolLayer";

                        private void _iceI_GetSelectedProtocolLayer(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetSelectedProtocolLayer_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task SelectProtocolLayerAsync(string protocolLayerName, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SelectProtocolLayerAsync(protocolLayerName, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SelectProtocolLayerAsync(string iceP_protocolLayerName, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SelectProtocolLayer_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SelectProtocolLayer(iceP_protocolLayerName, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SelectProtocolLayer_name = "SelectProtocolLayer";

                        private void _iceI_SelectProtocolLayer(string iceP_protocolLayerName, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SelectProtocolLayer_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_protocolLayerName);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetOverviewQueryAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewQueryAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetOverviewQueryAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewQuery_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetOverviewQuery(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewQuery_name = "GetOverviewQuery";

                        private void _iceI_GetOverviewQuery(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetOverviewQuery_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task SetOverviewQueryAsync(string query, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SetOverviewQueryAsync(query, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SetOverviewQueryAsync(string iceP_query, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SetOverviewQuery_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SetOverviewQuery(iceP_query, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SetOverviewQuery_name = "SetOverviewQuery";

                        private void _iceI_SetOverviewQuery(string iceP_query, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SetOverviewQuery_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_query);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<int> OverviewRootItemAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_OverviewRootItemAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int> _iceI_OverviewRootItemAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_OverviewRootItem_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int>(progress, cancel);
                            _iceI_OverviewRootItem(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _OverviewRootItem_name = "OverviewRootItem";

                        private void _iceI_OverviewRootItem(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int>(completed);
                            outAsync.invoke(
                                _OverviewRootItem_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int ret;
                                    ret = istr.readInt();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetOverviewItemDescriptionAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemDescriptionAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetOverviewItemDescriptionAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemDescription_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetOverviewItemDescription(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemDescription_name = "GetOverviewItemDescription";

                        private void _iceI_GetOverviewItemDescription(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetOverviewItemDescription_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetOverviewItemsDescriptionAsync(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemsDescriptionAsync(itemHandles, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetOverviewItemsDescriptionAsync(int[] iceP_itemHandles, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemsDescription_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetOverviewItemsDescription(iceP_itemHandles, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemsDescription_name = "GetOverviewItemsDescription";

                        private void _iceI_GetOverviewItemsDescription(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemsDescription_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.write(ostr, iceP_itemHandles);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<long> GetOverviewItemTimeInPicosecondsAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemTimeInPicosecondsAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<long> _iceI_GetOverviewItemTimeInPicosecondsAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemTimeInPicoseconds_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<long>(progress, cancel);
                            _iceI_GetOverviewItemTimeInPicoseconds(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemTimeInPicoseconds_name = "GetOverviewItemTimeInPicoseconds";

                        private void _iceI_GetOverviewItemTimeInPicoseconds(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<long>(completed);
                            outAsync.invoke(
                                _GetOverviewItemTimeInPicoseconds_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    long ret;
                                    ret = istr.readLong();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<long[]> GetOverviewItemsTimeInPicosecondsAsync(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemsTimeInPicosecondsAsync(itemHandles, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<long[]> _iceI_GetOverviewItemsTimeInPicosecondsAsync(int[] iceP_itemHandles, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemsTimeInPicoseconds_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<long[]>(progress, cancel);
                            _iceI_GetOverviewItemsTimeInPicoseconds(iceP_itemHandles, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemsTimeInPicoseconds_name = "GetOverviewItemsTimeInPicoseconds";

                        private void _iceI_GetOverviewItemsTimeInPicoseconds(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<long[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemsTimeInPicoseconds_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.write(ostr, iceP_itemHandles);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    long[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TimeArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<byte[]> GetOverviewItemDataAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemDataAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<byte[]> _iceI_GetOverviewItemDataAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemData_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<byte[]>(progress, cancel);
                            _iceI_GetOverviewItemData(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemData_name = "GetOverviewItemData";

                        private void _iceI_GetOverviewItemData(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<byte[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemData_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    byte[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ByteArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<byte[][]> GetOverviewItemsDataAsync(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemsDataAsync(itemHandles, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<byte[][]> _iceI_GetOverviewItemsDataAsync(int[] iceP_itemHandles, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemsData_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<byte[][]>(progress, cancel);
                            _iceI_GetOverviewItemsData(iceP_itemHandles, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemsData_name = "GetOverviewItemsData";

                        private void _iceI_GetOverviewItemsData(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<byte[][]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemsData_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.write(ostr, iceP_itemHandles);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    byte[][] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ByteArraysHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetOverviewItemXmlReportAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemXmlReportAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetOverviewItemXmlReportAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemXmlReport_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetOverviewItemXmlReport(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemXmlReport_name = "GetOverviewItemXmlReport";

                        private void _iceI_GetOverviewItemXmlReport(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetOverviewItemXmlReport_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetOverviewItemsXmlReportAsync(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemsXmlReportAsync(itemHandles, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetOverviewItemsXmlReportAsync(int[] iceP_itemHandles, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemsXmlReport_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetOverviewItemsXmlReport(iceP_itemHandles, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemsXmlReport_name = "GetOverviewItemsXmlReport";

                        private void _iceI_GetOverviewItemsXmlReport(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemsXmlReport_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.write(ostr, iceP_itemHandles);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string> GetOverviewItemXmlReportFilteredAsync(int itemHandle, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemXmlReportFilteredAsync(itemHandle, fieldNameFilters, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string> _iceI_GetOverviewItemXmlReportFilteredAsync(int iceP_itemHandle, string[] iceP_fieldNameFilters, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemXmlReportFiltered_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string>(progress, cancel);
                            _iceI_GetOverviewItemXmlReportFiltered(iceP_itemHandle, iceP_fieldNameFilters, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemXmlReportFiltered_name = "GetOverviewItemXmlReportFiltered";

                        private void _iceI_GetOverviewItemXmlReportFiltered(int iceP_itemHandle, string[] iceP_fieldNameFilters, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string>(completed);
                            outAsync.invoke(
                                _GetOverviewItemXmlReportFiltered_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string ret;
                                    ret = istr.readString();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<string[]> GetOverviewItemsXmlReportFilteredAsync(int[] itemHandles, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemsXmlReportFilteredAsync(itemHandles, fieldNameFilters, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<string[]> _iceI_GetOverviewItemsXmlReportFilteredAsync(int[] iceP_itemHandles, string[] iceP_fieldNameFilters, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemsXmlReportFiltered_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<string[]>(progress, cancel);
                            _iceI_GetOverviewItemsXmlReportFiltered(iceP_itemHandles, iceP_fieldNameFilters, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemsXmlReportFiltered_name = "GetOverviewItemsXmlReportFiltered";

                        private void _iceI_GetOverviewItemsXmlReportFiltered(int[] iceP_itemHandles, string[] iceP_fieldNameFilters, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<string[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemsXmlReportFiltered_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.write(ostr, iceP_itemHandles);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    string[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<int> GetOverviewItemChildCountAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemChildCountAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int> _iceI_GetOverviewItemChildCountAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemChildCount_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int>(progress, cancel);
                            _iceI_GetOverviewItemChildCount(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemChildCount_name = "GetOverviewItemChildCount";

                        private void _iceI_GetOverviewItemChildCount(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int>(completed);
                            outAsync.invoke(
                                _GetOverviewItemChildCount_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int ret;
                                    ret = istr.readInt();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<int> GetOverviewItemChildAsync(int itemHandle, int childIndex, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemChildAsync(itemHandle, childIndex, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int> _iceI_GetOverviewItemChildAsync(int iceP_itemHandle, int iceP_childIndex, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemChild_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int>(progress, cancel);
                            _iceI_GetOverviewItemChild(iceP_itemHandle, iceP_childIndex, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemChild_name = "GetOverviewItemChild";

                        private void _iceI_GetOverviewItemChild(int iceP_itemHandle, int iceP_childIndex, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int>(completed);
                            outAsync.invoke(
                                _GetOverviewItemChild_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                    ostr.writeInt(iceP_childIndex);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int ret;
                                    ret = istr.readInt();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<int[]> GetOverviewItemChildrenAsync(int itemHandle, int childIndex, int childCount, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetOverviewItemChildrenAsync(itemHandle, childIndex, childCount, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int[]> _iceI_GetOverviewItemChildrenAsync(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetOverviewItemChildren_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int[]>(progress, cancel);
                            _iceI_GetOverviewItemChildren(iceP_itemHandle, iceP_childIndex, iceP_childCount, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetOverviewItemChildren_name = "GetOverviewItemChildren";

                        private void _iceI_GetOverviewItemChildren(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int[]>(completed);
                            outAsync.invoke(
                                _GetOverviewItemChildren_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                    ostr.writeInt(iceP_childIndex);
                                    ostr.writeInt(iceP_childCount);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<int[]> SearchOverviewItemsAsync(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SearchOverviewItemsAsync(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int[]> _iceI_SearchOverviewItemsAsync(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, int iceP_maxDepth, string[] iceP_descriptionFilters, string[] iceP_fieldNameFilters, string[] iceP_fieldValueFilters, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SearchOverviewItems_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int[]>(progress, cancel);
                            _iceI_SearchOverviewItems(iceP_itemHandle, iceP_childIndex, iceP_childCount, iceP_maxDepth, iceP_descriptionFilters, iceP_fieldNameFilters, iceP_fieldValueFilters, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SearchOverviewItems_name = "SearchOverviewItems";

                        private void _iceI_SearchOverviewItems(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, int iceP_maxDepth, string[] iceP_descriptionFilters, string[] iceP_fieldNameFilters, string[] iceP_fieldValueFilters, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int[]>(completed);
                            outAsync.invoke(
                                _SearchOverviewItems_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                    ostr.writeInt(iceP_childIndex);
                                    ostr.writeInt(iceP_childCount);
                                    ostr.writeInt(iceP_maxDepth);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.write(ostr, iceP_descriptionFilters);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.StringArrayHelper.write(ostr, iceP_fieldValueFilters);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.HandleArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task ReleaseAllOverviewItemHandlesAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_ReleaseAllOverviewItemHandlesAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_ReleaseAllOverviewItemHandlesAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_ReleaseAllOverviewItemHandles_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_ReleaseAllOverviewItemHandles(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _ReleaseAllOverviewItemHandles_name = "ReleaseAllOverviewItemHandles";

                        private void _iceI_ReleaseAllOverviewItemHandles(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _ReleaseAllOverviewItemHandles_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task SelectOverviewItemAsync(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_SelectOverviewItemAsync(itemHandle, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_SelectOverviewItemAsync(int iceP_itemHandle, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_SelectOverviewItem_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_SelectOverviewItem(iceP_itemHandle, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _SelectOverviewItem_name = "SelectOverviewItem";

                        private void _iceI_SelectOverviewItem(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _SelectOverviewItem_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_itemHandle);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<int> GetSelectedOverviewItemAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetSelectedOverviewItemAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int> _iceI_GetSelectedOverviewItemAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetSelectedOverviewItem_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int>(progress, cancel);
                            _iceI_GetSelectedOverviewItem(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetSelectedOverviewItem_name = "GetSelectedOverviewItem";

                        private void _iceI_GetSelectedOverviewItem(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int>(completed);
                            outAsync.invoke(
                                _GetSelectedOverviewItem_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int ret;
                                    ret = istr.readInt();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<int> GetLogicSignalsStateAsync(long timeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetLogicSignalsStateAsync(timeInPicoseconds, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<int> _iceI_GetLogicSignalsStateAsync(long iceP_timeInPicoseconds, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetLogicSignalsState_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<int>(progress, cancel);
                            _iceI_GetLogicSignalsState(iceP_timeInPicoseconds, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetLogicSignalsState_name = "GetLogicSignalsState";

                        private void _iceI_GetLogicSignalsState(long iceP_timeInPicoseconds, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<int>(completed);
                            outAsync.invoke(
                                _GetLogicSignalsState_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeLong(iceP_timeInPicoseconds);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    int iceP_logicSignalsState;
                                    iceP_logicSignalsState = istr.readInt();
                                    return iceP_logicSignalsState;
                                });
                        }

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult> FindLogicSignalsTransitionAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_FindLogicSignalsTransitionAsync(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult> _iceI_FindLogicSignalsTransitionAsync(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType iceP_transitionType, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_FindLogicSignalsTransition_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult>(progress, cancel);
                            _iceI_FindLogicSignalsTransition(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, iceP_signalsMask, iceP_transitionType, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _FindLogicSignalsTransition_name = "FindLogicSignalsTransition";

                        private void _iceI_FindLogicSignalsTransition(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType iceP_transitionType, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult>(completed);
                            outAsync.invoke(
                                _FindLogicSignalsTransition_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeLong(iceP_fromTimeInPicoseconds);
                                    ostr.writeLong(iceP_toTimeInPicoseconds);
                                    ostr.writeInt(iceP_signalsMask);
                                    ostr.writeEnum((int)iceP_transitionType, 2);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult ret = new global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult();
                                    ret.foundLogicSignalsState = istr.readInt();
                                    ret.foundTimeInPicoseconds = istr.readLong();
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]> GetRunningTasksAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetRunningTasksAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]> _iceI_GetRunningTasksAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetRunningTasks_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]>(progress, cancel);
                            _iceI_GetRunningTasks(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetRunningTasks_name = "GetRunningTasks";

                        private void _iceI_GetRunningTasks(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]>(completed);
                            outAsync.invoke(
                                _GetRunningTasks_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTaskArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task AbortRunningTaskAsync(string name, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AbortRunningTaskAsync(name, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AbortRunningTaskAsync(string iceP_name, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_AbortRunningTask_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AbortRunningTask(iceP_name, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AbortRunningTask_name = "AbortRunningTask";

                        private void _iceI_AbortRunningTask(string iceP_name, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AbortRunningTask_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_name);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task<byte[]> GetSettingsAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_GetSettingsAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task<byte[]> _iceI_GetSettingsAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_GetSettings_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<byte[]>(progress, cancel);
                            _iceI_GetSettings(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _GetSettings_name = "GetSettings";

                        private void _iceI_GetSettings(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<byte[]>(completed);
                            outAsync.invoke(
                                _GetSettings_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                },
                                read: (global::Ice.InputStream istr) =>
                                {
                                    byte[] ret;
                                    ret = global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ByteArrayHelper.read(istr);
                                    return ret;
                                });
                        }

                        public global::System.Threading.Tasks.Task ConfigureSettingsAsync(byte[] settings, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_ConfigureSettingsAsync(settings, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_ConfigureSettingsAsync(byte[] iceP_settings, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_ConfigureSettings_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_ConfigureSettings(iceP_settings, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _ConfigureSettings_name = "ConfigureSettings";

                        private void _iceI_ConfigureSettings(byte[] iceP_settings, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _ConfigureSettings_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ByteArrayHelper.write(ostr, iceP_settings);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task CancelUserInteractionAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_CancelUserInteractionAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_CancelUserInteractionAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_CancelUserInteraction_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_CancelUserInteraction(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _CancelUserInteraction_name = "CancelUserInteraction";

                        private void _iceI_CancelUserInteraction(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _CancelUserInteraction_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task InsertCommentAsync(string comment, string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_InsertCommentAsync(comment, overviewName, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_InsertCommentAsync(string iceP_comment, string iceP_overviewName, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            iceCheckTwowayOnly(_InsertComment_name);
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_InsertComment(iceP_comment, iceP_overviewName, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _InsertComment_name = "InsertComment";

                        private void _iceI_InsertComment(string iceP_comment, string iceP_overviewName, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _InsertComment_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeString(iceP_comment);
                                    ostr.writeString(iceP_overviewName);
                                },
                                userException: (global::Ice.UserException ex) =>
                                {
                                    try
                                    {
                                        throw ex;
                                    }
                                    catch(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.OperationFailed)
                                    {
                                        throw;
                                    }
                                    catch(global::Ice.UserException)
                                    {
                                    }
                                });
                        }

                        public global::System.Threading.Tasks.Task AddThreadNetworkMasterKeyAsync(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AddThreadNetworkMasterKeyAsync(panId, key128, sequenceCounter, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AddThreadNetworkMasterKeyAsync(int iceP_panId, byte[] iceP_key128, long iceP_sequenceCounter, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AddThreadNetworkMasterKey(iceP_panId, iceP_key128, iceP_sequenceCounter, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AddThreadNetworkMasterKey_name = "AddThreadNetworkMasterKey";

                        private void _iceI_AddThreadNetworkMasterKey(int iceP_panId, byte[] iceP_key128, long iceP_sequenceCounter, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AddThreadNetworkMasterKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                    ostr.writeLong(iceP_sequenceCounter);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveThreadNetworkAllMasterKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveThreadNetworkAllMasterKeysAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveThreadNetworkAllMasterKeysAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveThreadNetworkAllMasterKeys(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveThreadNetworkAllMasterKeys_name = "RemoveThreadNetworkAllMasterKeys";

                        private void _iceI_RemoveThreadNetworkAllMasterKeys(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveThreadNetworkAllMasterKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous);
                        }

                        public global::System.Threading.Tasks.Task RemoveThreadNetworkMasterKeysAsync(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveThreadNetworkMasterKeysAsync(panId, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveThreadNetworkMasterKeysAsync(int iceP_panId, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveThreadNetworkMasterKeys(iceP_panId, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveThreadNetworkMasterKeys_name = "RemoveThreadNetworkMasterKeys";

                        private void _iceI_RemoveThreadNetworkMasterKeys(int iceP_panId, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveThreadNetworkMasterKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveThreadNetworkMasterKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveThreadNetworkMasterKeyAsync(panId, key128, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveThreadNetworkMasterKeyAsync(int iceP_panId, byte[] iceP_key128, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveThreadNetworkMasterKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveThreadNetworkMasterKey_name = "RemoveThreadNetworkMasterKey";

                        private void _iceI_RemoveThreadNetworkMasterKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveThreadNetworkMasterKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                });
                        }

                        public global::System.Threading.Tasks.Task AddZigbeeApsKeyAsync(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AddZigbeeApsKeyAsync(destinationAddress64, sourceAddress64, key128, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AddZigbeeApsKeyAsync(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AddZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AddZigbeeApsKey_name = "AddZigbeeApsKey";

                        private void _iceI_AddZigbeeApsKey(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AddZigbeeApsKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ByteArrayHelper.write(ostr, iceP_destinationAddress64);
                                    ByteArrayHelper.write(ostr, iceP_sourceAddress64);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeApsAllKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeApsAllKeysAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeApsAllKeysAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeApsAllKeys(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeApsAllKeys_name = "RemoveZigbeeApsAllKeys";

                        private void _iceI_RemoveZigbeeApsAllKeys(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeApsAllKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous);
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeApsKeysAsync(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeApsKeysAsync(destinationAddress64, sourceAddress64, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeApsKeysAsync(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeApsKeys(iceP_destinationAddress64, iceP_sourceAddress64, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeApsKeys_name = "RemoveZigbeeApsKeys";

                        private void _iceI_RemoveZigbeeApsKeys(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeApsKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ByteArrayHelper.write(ostr, iceP_destinationAddress64);
                                    ByteArrayHelper.write(ostr, iceP_sourceAddress64);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeApsKeyAsync(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeApsKeyAsync(destinationAddress64, sourceAddress64, key128, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeApsKeyAsync(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeApsKey_name = "RemoveZigbeeApsKey";

                        private void _iceI_RemoveZigbeeApsKey(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeApsKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ByteArrayHelper.write(ostr, iceP_destinationAddress64);
                                    ByteArrayHelper.write(ostr, iceP_sourceAddress64);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                });
                        }

                        public global::System.Threading.Tasks.Task AddZigbeeNetworkKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_AddZigbeeNetworkKeyAsync(panId, key128, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_AddZigbeeNetworkKeyAsync(int iceP_panId, byte[] iceP_key128, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_AddZigbeeNetworkKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _AddZigbeeNetworkKey_name = "AddZigbeeNetworkKey";

                        private void _iceI_AddZigbeeNetworkKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _AddZigbeeNetworkKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeNetworkAllKeysAsync(global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeNetworkAllKeysAsync(context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeNetworkAllKeysAsync(global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeNetworkAllKeys(context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeNetworkAllKeys_name = "RemoveZigbeeNetworkAllKeys";

                        private void _iceI_RemoveZigbeeNetworkAllKeys(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeNetworkAllKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous);
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeNetworkKeysAsync(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeNetworkKeysAsync(panId, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeNetworkKeysAsync(int iceP_panId, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeNetworkKeys(iceP_panId, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeNetworkKeys_name = "RemoveZigbeeNetworkKeys";

                        private void _iceI_RemoveZigbeeNetworkKeys(int iceP_panId, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeNetworkKeys_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                });
                        }

                        public global::System.Threading.Tasks.Task RemoveZigbeeNetworkKeyAsync(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext(), global::System.IProgress<bool> progress = null, global::System.Threading.CancellationToken cancel = new global::System.Threading.CancellationToken())
                        {
                            return _iceI_RemoveZigbeeNetworkKeyAsync(panId, key128, context, progress, cancel, false);
                        }

                        private global::System.Threading.Tasks.Task _iceI_RemoveZigbeeNetworkKeyAsync(int iceP_panId, byte[] iceP_key128, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                            _iceI_RemoveZigbeeNetworkKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed.Task;
                        }

                        private const string _RemoveZigbeeNetworkKey_name = "RemoveZigbeeNetworkKey";

                        private void _iceI_RemoveZigbeeNetworkKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                        {
                            var outAsync = getOutgoingAsync<object>(completed);
                            outAsync.invoke(
                                _RemoveZigbeeNetworkKey_name,
                                global::Ice.OperationMode.Normal,
                                global::Ice.FormatType.DefaultFormat,
                                context,
                                synchronous,
                                write: (global::Ice.OutputStream ostr) =>
                                {
                                    ostr.writeInt(iceP_panId);
                                    ByteArrayHelper.write(ostr, iceP_key128);
                                });
                        }

                        #endregion

                        #region Asynchronous operations

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAppInfo> begin_GetAppInfo(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetAppInfo(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetAppInfo(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAppInfo(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetAppInfo(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAppInfo(context, callback, cookie, false);
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo end_GetAppInfo(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetAppInfo_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAppInfo> begin_GetAppInfo(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetAppInfo_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAppInfo, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAppInfo cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetAppInfo_name, cookie, completedCallback);
                            _iceI_GetAppInfo(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ExitApp> begin_ExitApp(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_ExitApp(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_ExitApp(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ExitApp(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_ExitApp(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ExitApp(context, callback, cookie, false);
                        }

                        public void end_ExitApp(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _ExitApp_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ExitApp> begin_ExitApp(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_ExitApp_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ExitApp, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ExitApp cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _ExitApp_name, cookie, completedCallback);
                            _iceI_ExitApp(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableDataSources> begin_GetAvailableDataSources(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetAvailableDataSources(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableDataSources(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableDataSources(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableDataSources(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableDataSources(context, callback, cookie, false);
                        }

                        public string[] end_GetAvailableDataSources(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetAvailableDataSources_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableDataSources> begin_GetAvailableDataSources(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetAvailableDataSources_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableDataSources, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableDataSources cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetAvailableDataSources_name, cookie, completedCallback);
                            _iceI_GetAvailableDataSources(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectDataSource> begin_SelectDataSource(string dataSourceUniqueId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SelectDataSource(dataSourceUniqueId, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SelectDataSource(string dataSourceUniqueId, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectDataSource(dataSourceUniqueId, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SelectDataSource(string dataSourceUniqueId, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectDataSource(dataSourceUniqueId, context, callback, cookie, false);
                        }

                        public void end_SelectDataSource(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SelectDataSource_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectDataSource> begin_SelectDataSource(string iceP_dataSourceUniqueId, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SelectDataSource_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectDataSource, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectDataSource cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SelectDataSource_name, cookie, completedCallback);
                            _iceI_SelectDataSource(iceP_dataSourceUniqueId, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedDataSource> begin_GetSelectedDataSource(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetSelectedDataSource(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedDataSource(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedDataSource(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedDataSource(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedDataSource(context, callback, cookie, false);
                        }

                        public string end_GetSelectedDataSource(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSelectedDataSource_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedDataSource> begin_GetSelectedDataSource(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetSelectedDataSource_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedDataSource, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedDataSource cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetSelectedDataSource_name, cookie, completedCallback);
                            _iceI_GetSelectedDataSource(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsRecording> begin_IsRecording(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_IsRecording(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_IsRecording(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsRecording(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_IsRecording(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsRecording(context, callback, cookie, false);
                        }

                        public bool end_IsRecording(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _IsRecording_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<bool>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsRecording> begin_IsRecording(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_IsRecording_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsRecording, bool>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsRecording cb, bool ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _IsRecording_name, cookie, completedCallback);
                            _iceI_IsRecording(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingStatus> begin_GetRecordingStatus(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetRecordingStatus(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetRecordingStatus(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRecordingStatus(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetRecordingStatus(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRecordingStatus(context, callback, cookie, false);
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus end_GetRecordingStatus(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetRecordingStatus_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingStatus> begin_GetRecordingStatus(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetRecordingStatus_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingStatus, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingStatus cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetRecordingStatus_name, cookie, completedCallback);
                            _iceI_GetRecordingStatus(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartRecording> begin_StartRecording(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_StartRecording(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_StartRecording(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StartRecording(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_StartRecording(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StartRecording(context, callback, cookie, false);
                        }

                        public void end_StartRecording(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _StartRecording_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartRecording> begin_StartRecording(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_StartRecording_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartRecording, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartRecording cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _StartRecording_name, cookie, completedCallback);
                            _iceI_StartRecording(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StopRecordingAndSaveTraceFile> begin_StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_StopRecordingAndSaveTraceFile(filename, overwrite, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StopRecordingAndSaveTraceFile(filename, overwrite, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StopRecordingAndSaveTraceFile(filename, overwrite, context, callback, cookie, false);
                        }

                        public void end_StopRecordingAndSaveTraceFile(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _StopRecordingAndSaveTraceFile_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StopRecordingAndSaveTraceFile> begin_StopRecordingAndSaveTraceFile(string iceP_filename, bool iceP_overwrite, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_StopRecordingAndSaveTraceFile_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StopRecordingAndSaveTraceFile, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StopRecordingAndSaveTraceFile cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _StopRecordingAndSaveTraceFile_name, cookie, completedCallback);
                            _iceI_StopRecordingAndSaveTraceFile(iceP_filename, iceP_overwrite, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRecordingAndDiscardTraceFile> begin_AbortRecordingAndDiscardTraceFile(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AbortRecordingAndDiscardTraceFile(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AbortRecordingAndDiscardTraceFile(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AbortRecordingAndDiscardTraceFile(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AbortRecordingAndDiscardTraceFile(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AbortRecordingAndDiscardTraceFile(context, callback, cookie, false);
                        }

                        public void end_AbortRecordingAndDiscardTraceFile(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AbortRecordingAndDiscardTraceFile_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRecordingAndDiscardTraceFile> begin_AbortRecordingAndDiscardTraceFile(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_AbortRecordingAndDiscardTraceFile_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRecordingAndDiscardTraceFile, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRecordingAndDiscardTraceFile cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AbortRecordingAndDiscardTraceFile_name, cookie, completedCallback);
                            _iceI_AbortRecordingAndDiscardTraceFile(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingOptions> begin_GetRecordingOptions(bool relevantOnly, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetRecordingOptions(relevantOnly, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetRecordingOptions(bool relevantOnly, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRecordingOptions(relevantOnly, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetRecordingOptions(bool relevantOnly, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRecordingOptions(relevantOnly, context, callback, cookie, false);
                        }

                        public string end_GetRecordingOptions(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetRecordingOptions_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingOptions> begin_GetRecordingOptions(bool iceP_relevantOnly, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetRecordingOptions_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingOptions, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRecordingOptions cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetRecordingOptions_name, cookie, completedCallback);
                            _iceI_GetRecordingOptions(iceP_relevantOnly, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureRecordingOptions> begin_ConfigureRecordingOptions(string options, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_ConfigureRecordingOptions(options, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_ConfigureRecordingOptions(string options, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ConfigureRecordingOptions(options, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_ConfigureRecordingOptions(string options, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ConfigureRecordingOptions(options, context, callback, cookie, false);
                        }

                        public void end_ConfigureRecordingOptions(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _ConfigureRecordingOptions_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureRecordingOptions> begin_ConfigureRecordingOptions(string iceP_options, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_ConfigureRecordingOptions_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureRecordingOptions, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureRecordingOptions cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _ConfigureRecordingOptions_name, cookie, completedCallback);
                            _iceI_ConfigureRecordingOptions(iceP_options, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertMessage> begin_InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_InsertMessage(severity, message, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_InsertMessage(severity, message, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_InsertMessage(severity, message, context, callback, cookie, false);
                        }

                        public void end_InsertMessage(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _InsertMessage_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertMessage> begin_InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity iceP_severity, string iceP_message, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_InsertMessage_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertMessage, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertMessage cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _InsertMessage_name, cookie, completedCallback);
                            _iceI_InsertMessage(iceP_severity, iceP_message, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsLoading> begin_IsLoading(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_IsLoading(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_IsLoading(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsLoading(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_IsLoading(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsLoading(context, callback, cookie, false);
                        }

                        public bool end_IsLoading(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _IsLoading_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<bool>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsLoading> begin_IsLoading(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_IsLoading_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsLoading, bool>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsLoading cb, bool ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _IsLoading_name, cookie, completedCallback);
                            _iceI_IsLoading(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartLoading> begin_StartLoading(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_StartLoading(filename, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_StartLoading(string filename, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StartLoading(filename, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_StartLoading(string filename, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_StartLoading(filename, context, callback, cookie, false);
                        }

                        public void end_StartLoading(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _StartLoading_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartLoading> begin_StartLoading(string iceP_filename, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_StartLoading_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartLoading, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_StartLoading cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _StartLoading_name, cookie, completedCallback);
                            _iceI_StartLoading(iceP_filename, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetTraceFileInfo> begin_GetTraceFileInfo(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetTraceFileInfo(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetTraceFileInfo(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetTraceFileInfo(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetTraceFileInfo(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetTraceFileInfo(context, callback, cookie, false);
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo end_GetTraceFileInfo(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetTraceFileInfo_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetTraceFileInfo> begin_GetTraceFileInfo(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetTraceFileInfo_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetTraceFileInfo, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetTraceFileInfo cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetTraceFileInfo_name, cookie, completedCallback);
                            _iceI_GetTraceFileInfo(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CloseTraceFile> begin_CloseTraceFile(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_CloseTraceFile(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_CloseTraceFile(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_CloseTraceFile(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_CloseTraceFile(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_CloseTraceFile(context, callback, cookie, false);
                        }

                        public void end_CloseTraceFile(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _CloseTraceFile_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CloseTraceFile> begin_CloseTraceFile(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_CloseTraceFile_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CloseTraceFile, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CloseTraceFile cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _CloseTraceFile_name, cookie, completedCallback);
                            _iceI_CloseTraceFile(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsModified> begin_IsModified(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_IsModified(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_IsModified(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsModified(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_IsModified(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_IsModified(context, callback, cookie, false);
                        }

                        public bool end_IsModified(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _IsModified_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<bool>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsModified> begin_IsModified(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_IsModified_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsModified, bool>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_IsModified cb, bool ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _IsModified_name, cookie, completedCallback);
                            _iceI_IsModified(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SaveChanges> begin_SaveChanges(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SaveChanges(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SaveChanges(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SaveChanges(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SaveChanges(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SaveChanges(context, callback, cookie, false);
                        }

                        public void end_SaveChanges(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SaveChanges_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SaveChanges> begin_SaveChanges(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SaveChanges_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SaveChanges, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SaveChanges cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SaveChanges_name, cookie, completedCallback);
                            _iceI_SaveChanges(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem> begin_AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AddMarkerOnSelectedOverviewItem(marker, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddMarkerOnSelectedOverviewItem(marker, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddMarkerOnSelectedOverviewItem(marker, context, callback, cookie, false);
                        }

                        public void end_AddMarkerOnSelectedOverviewItem(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AddMarkerOnSelectedOverviewItem_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem> begin_AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_AddMarkerOnSelectedOverviewItem_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AddMarkerOnSelectedOverviewItem_name, cookie, completedCallback);
                            _iceI_AddMarkerOnSelectedOverviewItem(iceP_marker, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerAtTime> begin_AddMarkerAtTime(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AddMarkerAtTime(timeInPicoseconds, marker, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AddMarkerAtTime(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddMarkerAtTime(timeInPicoseconds, marker, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AddMarkerAtTime(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddMarkerAtTime(timeInPicoseconds, marker, context, callback, cookie, false);
                        }

                        public void end_AddMarkerAtTime(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AddMarkerAtTime_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerAtTime> begin_AddMarkerAtTime(long iceP_timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker iceP_marker, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_AddMarkerAtTime_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerAtTime, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AddMarkerAtTime cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AddMarkerAtTime_name, cookie, completedCallback);
                            _iceI_AddMarkerAtTime(iceP_timeInPicoseconds, iceP_marker, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetMarkers> begin_GetMarkers(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetMarkers(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetMarkers(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetMarkers(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetMarkers(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetMarkers(context, callback, cookie, false);
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[] end_GetMarkers(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetMarkers_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetMarkers> begin_GetMarkers(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetMarkers_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetMarkers, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetMarkers cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetMarkers_name, cookie, completedCallback);
                            _iceI_GetMarkers(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_Export> begin_Export(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_Export(outputFilename, exportName, exportOptions, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_Export(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_Export(outputFilename, exportName, exportOptions, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_Export(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_Export(outputFilename, exportName, exportOptions, context, callback, cookie, false);
                        }

                        public void end_Export(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _Export_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_Export> begin_Export(string iceP_outputFilename, string iceP_exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] iceP_exportOptions, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_Export_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_Export, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_Export cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _Export_name, cookie, completedCallback);
                            _iceI_Export(iceP_outputFilename, iceP_exportName, iceP_exportOptions, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableOverviews> begin_GetAvailableOverviews(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetAvailableOverviews(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableOverviews(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableOverviews(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableOverviews(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableOverviews(context, callback, cookie, false);
                        }

                        public string[] end_GetAvailableOverviews(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetAvailableOverviews_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableOverviews> begin_GetAvailableOverviews(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetAvailableOverviews_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableOverviews, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableOverviews cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetAvailableOverviews_name, cookie, completedCallback);
                            _iceI_GetAvailableOverviews(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverview> begin_GetSelectedOverview(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetSelectedOverview(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedOverview(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedOverview(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedOverview(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedOverview(context, callback, cookie, false);
                        }

                        public string end_GetSelectedOverview(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSelectedOverview_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverview> begin_GetSelectedOverview(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetSelectedOverview_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverview, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverview cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetSelectedOverview_name, cookie, completedCallback);
                            _iceI_GetSelectedOverview(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverview> begin_SelectOverview(string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SelectOverview(overviewName, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SelectOverview(string overviewName, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectOverview(overviewName, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SelectOverview(string overviewName, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectOverview(overviewName, context, callback, cookie, false);
                        }

                        public void end_SelectOverview(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SelectOverview_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverview> begin_SelectOverview(string iceP_overviewName, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SelectOverview_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverview, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverview cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SelectOverview_name, cookie, completedCallback);
                            _iceI_SelectOverview(iceP_overviewName, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableProtocolLayers> begin_GetAvailableProtocolLayers(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetAvailableProtocolLayers(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableProtocolLayers(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableProtocolLayers(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetAvailableProtocolLayers(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetAvailableProtocolLayers(context, callback, cookie, false);
                        }

                        public string[] end_GetAvailableProtocolLayers(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetAvailableProtocolLayers_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableProtocolLayers> begin_GetAvailableProtocolLayers(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetAvailableProtocolLayers_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableProtocolLayers, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetAvailableProtocolLayers cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetAvailableProtocolLayers_name, cookie, completedCallback);
                            _iceI_GetAvailableProtocolLayers(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedProtocolLayer> begin_GetSelectedProtocolLayer(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetSelectedProtocolLayer(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedProtocolLayer(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedProtocolLayer(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedProtocolLayer(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedProtocolLayer(context, callback, cookie, false);
                        }

                        public string end_GetSelectedProtocolLayer(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSelectedProtocolLayer_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedProtocolLayer> begin_GetSelectedProtocolLayer(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetSelectedProtocolLayer_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedProtocolLayer, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedProtocolLayer cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetSelectedProtocolLayer_name, cookie, completedCallback);
                            _iceI_GetSelectedProtocolLayer(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectProtocolLayer> begin_SelectProtocolLayer(string protocolLayerName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SelectProtocolLayer(protocolLayerName, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SelectProtocolLayer(string protocolLayerName, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectProtocolLayer(protocolLayerName, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SelectProtocolLayer(string protocolLayerName, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectProtocolLayer(protocolLayerName, context, callback, cookie, false);
                        }

                        public void end_SelectProtocolLayer(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SelectProtocolLayer_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectProtocolLayer> begin_SelectProtocolLayer(string iceP_protocolLayerName, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SelectProtocolLayer_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectProtocolLayer, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectProtocolLayer cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SelectProtocolLayer_name, cookie, completedCallback);
                            _iceI_SelectProtocolLayer(iceP_protocolLayerName, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewQuery> begin_GetOverviewQuery(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewQuery(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewQuery(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewQuery(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewQuery(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewQuery(context, callback, cookie, false);
                        }

                        public string end_GetOverviewQuery(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewQuery_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewQuery> begin_GetOverviewQuery(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewQuery_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewQuery, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewQuery cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewQuery_name, cookie, completedCallback);
                            _iceI_GetOverviewQuery(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SetOverviewQuery> begin_SetOverviewQuery(string query, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SetOverviewQuery(query, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SetOverviewQuery(string query, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SetOverviewQuery(query, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SetOverviewQuery(string query, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SetOverviewQuery(query, context, callback, cookie, false);
                        }

                        public void end_SetOverviewQuery(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SetOverviewQuery_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SetOverviewQuery> begin_SetOverviewQuery(string iceP_query, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SetOverviewQuery_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SetOverviewQuery, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SetOverviewQuery cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SetOverviewQuery_name, cookie, completedCallback);
                            _iceI_SetOverviewQuery(iceP_query, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_OverviewRootItem> begin_OverviewRootItem(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_OverviewRootItem(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_OverviewRootItem(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_OverviewRootItem(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_OverviewRootItem(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_OverviewRootItem(context, callback, cookie, false);
                        }

                        public int end_OverviewRootItem(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _OverviewRootItem_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_OverviewRootItem> begin_OverviewRootItem(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_OverviewRootItem_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_OverviewRootItem, int>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_OverviewRootItem cb, int ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _OverviewRootItem_name, cookie, completedCallback);
                            _iceI_OverviewRootItem(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemDescription> begin_GetOverviewItemDescription(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemDescription(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemDescription(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemDescription(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemDescription(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemDescription(itemHandle, context, callback, cookie, false);
                        }

                        public string end_GetOverviewItemDescription(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemDescription_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemDescription> begin_GetOverviewItemDescription(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemDescription_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemDescription, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemDescription cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemDescription_name, cookie, completedCallback);
                            _iceI_GetOverviewItemDescription(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsDescription> begin_GetOverviewItemsDescription(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemsDescription(itemHandles, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsDescription(int[] itemHandles, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsDescription(itemHandles, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsDescription(int[] itemHandles, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsDescription(itemHandles, context, callback, cookie, false);
                        }

                        public string[] end_GetOverviewItemsDescription(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemsDescription_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsDescription> begin_GetOverviewItemsDescription(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemsDescription_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsDescription, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsDescription cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemsDescription_name, cookie, completedCallback);
                            _iceI_GetOverviewItemsDescription(iceP_itemHandles, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemTimeInPicoseconds> begin_GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemTimeInPicoseconds(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemTimeInPicoseconds(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemTimeInPicoseconds(itemHandle, context, callback, cookie, false);
                        }

                        public long end_GetOverviewItemTimeInPicoseconds(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemTimeInPicoseconds_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<long>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemTimeInPicoseconds> begin_GetOverviewItemTimeInPicoseconds(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemTimeInPicoseconds_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemTimeInPicoseconds, long>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemTimeInPicoseconds cb, long ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemTimeInPicoseconds_name, cookie, completedCallback);
                            _iceI_GetOverviewItemTimeInPicoseconds(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsTimeInPicoseconds> begin_GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemsTimeInPicoseconds(itemHandles, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsTimeInPicoseconds(itemHandles, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsTimeInPicoseconds(itemHandles, context, callback, cookie, false);
                        }

                        public long[] end_GetOverviewItemsTimeInPicoseconds(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemsTimeInPicoseconds_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<long[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsTimeInPicoseconds> begin_GetOverviewItemsTimeInPicoseconds(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemsTimeInPicoseconds_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsTimeInPicoseconds, long[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsTimeInPicoseconds cb, long[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemsTimeInPicoseconds_name, cookie, completedCallback);
                            _iceI_GetOverviewItemsTimeInPicoseconds(iceP_itemHandles, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemData> begin_GetOverviewItemData(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemData(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemData(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemData(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemData(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemData(itemHandle, context, callback, cookie, false);
                        }

                        public byte[] end_GetOverviewItemData(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemData_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<byte[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemData> begin_GetOverviewItemData(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemData_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemData, byte[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemData cb, byte[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemData_name, cookie, completedCallback);
                            _iceI_GetOverviewItemData(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsData> begin_GetOverviewItemsData(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemsData(itemHandles, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsData(int[] itemHandles, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsData(itemHandles, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsData(int[] itemHandles, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsData(itemHandles, context, callback, cookie, false);
                        }

                        public byte[][] end_GetOverviewItemsData(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemsData_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<byte[][]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsData> begin_GetOverviewItemsData(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemsData_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsData, byte[][]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsData cb, byte[][] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemsData_name, cookie, completedCallback);
                            _iceI_GetOverviewItemsData(iceP_itemHandles, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReport> begin_GetOverviewItemXmlReport(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemXmlReport(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemXmlReport(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemXmlReport(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemXmlReport(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemXmlReport(itemHandle, context, callback, cookie, false);
                        }

                        public string end_GetOverviewItemXmlReport(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemXmlReport_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReport> begin_GetOverviewItemXmlReport(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemXmlReport_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReport, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReport cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemXmlReport_name, cookie, completedCallback);
                            _iceI_GetOverviewItemXmlReport(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReport> begin_GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemsXmlReport(itemHandles, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsXmlReport(itemHandles, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsXmlReport(itemHandles, context, callback, cookie, false);
                        }

                        public string[] end_GetOverviewItemsXmlReport(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemsXmlReport_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReport> begin_GetOverviewItemsXmlReport(int[] iceP_itemHandles, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemsXmlReport_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReport, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReport cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemsXmlReport_name, cookie, completedCallback);
                            _iceI_GetOverviewItemsXmlReport(iceP_itemHandles, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReportFiltered> begin_GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemXmlReportFiltered(itemHandle, fieldNameFilters, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemXmlReportFiltered(itemHandle, fieldNameFilters, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemXmlReportFiltered(itemHandle, fieldNameFilters, context, callback, cookie, false);
                        }

                        public string end_GetOverviewItemXmlReportFiltered(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemXmlReportFiltered_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReportFiltered> begin_GetOverviewItemXmlReportFiltered(int iceP_itemHandle, string[] iceP_fieldNameFilters, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemXmlReportFiltered_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReportFiltered, string>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemXmlReportFiltered cb, string ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemXmlReportFiltered_name, cookie, completedCallback);
                            _iceI_GetOverviewItemXmlReportFiltered(iceP_itemHandle, iceP_fieldNameFilters, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReportFiltered> begin_GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemsXmlReportFiltered(itemHandles, fieldNameFilters, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsXmlReportFiltered(itemHandles, fieldNameFilters, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemsXmlReportFiltered(itemHandles, fieldNameFilters, context, callback, cookie, false);
                        }

                        public string[] end_GetOverviewItemsXmlReportFiltered(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemsXmlReportFiltered_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<string[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReportFiltered> begin_GetOverviewItemsXmlReportFiltered(int[] iceP_itemHandles, string[] iceP_fieldNameFilters, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemsXmlReportFiltered_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReportFiltered, string[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReportFiltered cb, string[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemsXmlReportFiltered_name, cookie, completedCallback);
                            _iceI_GetOverviewItemsXmlReportFiltered(iceP_itemHandles, iceP_fieldNameFilters, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildCount> begin_GetOverviewItemChildCount(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemChildCount(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChildCount(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChildCount(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChildCount(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChildCount(itemHandle, context, callback, cookie, false);
                        }

                        public int end_GetOverviewItemChildCount(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemChildCount_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildCount> begin_GetOverviewItemChildCount(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemChildCount_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildCount, int>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildCount cb, int ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemChildCount_name, cookie, completedCallback);
                            _iceI_GetOverviewItemChildCount(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChild> begin_GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemChild(itemHandle, childIndex, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChild(itemHandle, childIndex, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChild(itemHandle, childIndex, context, callback, cookie, false);
                        }

                        public int end_GetOverviewItemChild(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemChild_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChild> begin_GetOverviewItemChild(int iceP_itemHandle, int iceP_childIndex, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemChild_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChild, int>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChild cb, int ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemChild_name, cookie, completedCallback);
                            _iceI_GetOverviewItemChild(iceP_itemHandle, iceP_childIndex, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildren> begin_GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetOverviewItemChildren(itemHandle, childIndex, childCount, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChildren(itemHandle, childIndex, childCount, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetOverviewItemChildren(itemHandle, childIndex, childCount, context, callback, cookie, false);
                        }

                        public int[] end_GetOverviewItemChildren(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetOverviewItemChildren_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildren> begin_GetOverviewItemChildren(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetOverviewItemChildren_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildren, int[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetOverviewItemChildren cb, int[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetOverviewItemChildren_name, cookie, completedCallback);
                            _iceI_GetOverviewItemChildren(iceP_itemHandle, iceP_childIndex, iceP_childCount, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SearchOverviewItems> begin_SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SearchOverviewItems(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SearchOverviewItems(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SearchOverviewItems(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, context, callback, cookie, false);
                        }

                        public int[] end_SearchOverviewItems(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SearchOverviewItems_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SearchOverviewItems> begin_SearchOverviewItems(int iceP_itemHandle, int iceP_childIndex, int iceP_childCount, int iceP_maxDepth, string[] iceP_descriptionFilters, string[] iceP_fieldNameFilters, string[] iceP_fieldValueFilters, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SearchOverviewItems_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SearchOverviewItems, int[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SearchOverviewItems cb, int[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _SearchOverviewItems_name, cookie, completedCallback);
                            _iceI_SearchOverviewItems(iceP_itemHandle, iceP_childIndex, iceP_childCount, iceP_maxDepth, iceP_descriptionFilters, iceP_fieldNameFilters, iceP_fieldValueFilters, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ReleaseAllOverviewItemHandles> begin_ReleaseAllOverviewItemHandles(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_ReleaseAllOverviewItemHandles(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_ReleaseAllOverviewItemHandles(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ReleaseAllOverviewItemHandles(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_ReleaseAllOverviewItemHandles(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ReleaseAllOverviewItemHandles(context, callback, cookie, false);
                        }

                        public void end_ReleaseAllOverviewItemHandles(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _ReleaseAllOverviewItemHandles_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ReleaseAllOverviewItemHandles> begin_ReleaseAllOverviewItemHandles(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_ReleaseAllOverviewItemHandles_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ReleaseAllOverviewItemHandles, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ReleaseAllOverviewItemHandles cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _ReleaseAllOverviewItemHandles_name, cookie, completedCallback);
                            _iceI_ReleaseAllOverviewItemHandles(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverviewItem> begin_SelectOverviewItem(int itemHandle, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_SelectOverviewItem(itemHandle, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_SelectOverviewItem(int itemHandle, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectOverviewItem(itemHandle, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_SelectOverviewItem(int itemHandle, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_SelectOverviewItem(itemHandle, context, callback, cookie, false);
                        }

                        public void end_SelectOverviewItem(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _SelectOverviewItem_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverviewItem> begin_SelectOverviewItem(int iceP_itemHandle, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_SelectOverviewItem_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverviewItem, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_SelectOverviewItem cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _SelectOverviewItem_name, cookie, completedCallback);
                            _iceI_SelectOverviewItem(iceP_itemHandle, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverviewItem> begin_GetSelectedOverviewItem(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetSelectedOverviewItem(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedOverviewItem(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedOverviewItem(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetSelectedOverviewItem(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSelectedOverviewItem(context, callback, cookie, false);
                        }

                        public int end_GetSelectedOverviewItem(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSelectedOverviewItem_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverviewItem> begin_GetSelectedOverviewItem(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetSelectedOverviewItem_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverviewItem, int>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSelectedOverviewItem cb, int ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetSelectedOverviewItem_name, cookie, completedCallback);
                            _iceI_GetSelectedOverviewItem(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetLogicSignalsState> begin_GetLogicSignalsState(long timeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetLogicSignalsState(timeInPicoseconds, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetLogicSignalsState(long timeInPicoseconds, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetLogicSignalsState(timeInPicoseconds, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetLogicSignalsState(long timeInPicoseconds, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetLogicSignalsState(timeInPicoseconds, context, callback, cookie, false);
                        }

                        public void end_GetLogicSignalsState(out int logicSignalsState, global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetLogicSignalsState_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<int>)resultI_.OutgoingAsync;
                            logicSignalsState = outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetLogicSignalsState> begin_GetLogicSignalsState(long iceP_timeInPicoseconds, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetLogicSignalsState_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetLogicSignalsState, int>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetLogicSignalsState cb, int ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetLogicSignalsState_name, cookie, completedCallback);
                            _iceI_GetLogicSignalsState(iceP_timeInPicoseconds, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_FindLogicSignalsTransition> begin_FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_FindLogicSignalsTransition(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_FindLogicSignalsTransition(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_FindLogicSignalsTransition(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, context, callback, cookie, false);
                        }

                        public void end_FindLogicSignalsTransition(out int foundLogicSignalsState, out long foundTimeInPicoseconds, global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _FindLogicSignalsTransition_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult>)resultI_.OutgoingAsync;
                            var result_ = outgoing_.getResult(resultI_.wait());
                            foundLogicSignalsState = result_.foundLogicSignalsState;
                            foundTimeInPicoseconds = result_.foundTimeInPicoseconds;
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_FindLogicSignalsTransition> begin_FindLogicSignalsTransition(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType iceP_transitionType, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_FindLogicSignalsTransition_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_FindLogicSignalsTransition, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_FindLogicSignalsTransition cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControl_FindLogicSignalsTransitionResult ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret.foundLogicSignalsState, ret.foundTimeInPicoseconds);
                                    }
                                },
                                this, _FindLogicSignalsTransition_name, cookie, completedCallback);
                            _iceI_FindLogicSignalsTransition(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, iceP_signalsMask, iceP_transitionType, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRunningTasks> begin_GetRunningTasks(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetRunningTasks(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetRunningTasks(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRunningTasks(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetRunningTasks(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetRunningTasks(context, callback, cookie, false);
                        }

                        public global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[] end_GetRunningTasks(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetRunningTasks_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRunningTasks> begin_GetRunningTasks(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetRunningTasks_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRunningTasks, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetRunningTasks cb, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetRunningTasks_name, cookie, completedCallback);
                            _iceI_GetRunningTasks(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRunningTask> begin_AbortRunningTask(string name, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AbortRunningTask(name, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AbortRunningTask(string name, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AbortRunningTask(name, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AbortRunningTask(string name, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AbortRunningTask(name, context, callback, cookie, false);
                        }

                        public void end_AbortRunningTask(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AbortRunningTask_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRunningTask> begin_AbortRunningTask(string iceP_name, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_AbortRunningTask_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRunningTask, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_AbortRunningTask cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AbortRunningTask_name, cookie, completedCallback);
                            _iceI_AbortRunningTask(iceP_name, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSettings> begin_GetSettings(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_GetSettings(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_GetSettings(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSettings(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_GetSettings(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_GetSettings(context, callback, cookie, false);
                        }

                        public byte[] end_GetSettings(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSettings_name);
                            var outgoing_ = (global::IceInternal.OutgoingAsyncT<byte[]>)resultI_.OutgoingAsync;
                            return outgoing_.getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSettings> begin_GetSettings(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_GetSettings_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSettings, byte[]>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_GetSettings cb, byte[] ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke(ret);
                                    }
                                },
                                this, _GetSettings_name, cookie, completedCallback);
                            _iceI_GetSettings(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureSettings> begin_ConfigureSettings(byte[] settings, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_ConfigureSettings(settings, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_ConfigureSettings(byte[] settings, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ConfigureSettings(settings, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_ConfigureSettings(byte[] settings, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_ConfigureSettings(settings, context, callback, cookie, false);
                        }

                        public void end_ConfigureSettings(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _ConfigureSettings_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureSettings> begin_ConfigureSettings(byte[] iceP_settings, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_ConfigureSettings_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureSettings, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_ConfigureSettings cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _ConfigureSettings_name, cookie, completedCallback);
                            _iceI_ConfigureSettings(iceP_settings, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CancelUserInteraction> begin_CancelUserInteraction(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_CancelUserInteraction(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_CancelUserInteraction(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_CancelUserInteraction(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_CancelUserInteraction(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_CancelUserInteraction(context, callback, cookie, false);
                        }

                        public void end_CancelUserInteraction(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _CancelUserInteraction_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CancelUserInteraction> begin_CancelUserInteraction(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_CancelUserInteraction_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CancelUserInteraction, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_CancelUserInteraction cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _CancelUserInteraction_name, cookie, completedCallback);
                            _iceI_CancelUserInteraction(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertComment> begin_InsertComment(string comment, string overviewName, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_InsertComment(comment, overviewName, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_InsertComment(string comment, string overviewName, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_InsertComment(comment, overviewName, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_InsertComment(string comment, string overviewName, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_InsertComment(comment, overviewName, context, callback, cookie, false);
                        }

                        public void end_InsertComment(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _InsertComment_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertComment> begin_InsertComment(string iceP_comment, string iceP_overviewName, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            iceCheckAsyncTwowayOnly(_InsertComment_name);
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertComment, object>(
                                (global::Ellisys.Platform.NetworkRemoteControl.Analyzer.Callback_AnalyzerRemoteControl_InsertComment cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _InsertComment_name, cookie, completedCallback);
                            _iceI_InsertComment(iceP_comment, iceP_overviewName, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey> begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AddThreadNetworkMasterKey(panId, key128, sequenceCounter, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddThreadNetworkMasterKey(panId, key128, sequenceCounter, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddThreadNetworkMasterKey(panId, key128, sequenceCounter, context, callback, cookie, false);
                        }

                        public void end_AddThreadNetworkMasterKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AddThreadNetworkMasterKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey> begin_AddThreadNetworkMasterKey(int iceP_panId, byte[] iceP_key128, long iceP_sequenceCounter, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_AddThreadNetworkMasterKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AddThreadNetworkMasterKey_name, cookie, completedCallback);
                            _iceI_AddThreadNetworkMasterKey(iceP_panId, iceP_key128, iceP_sequenceCounter, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys> begin_RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveThreadNetworkAllMasterKeys(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkAllMasterKeys(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkAllMasterKeys(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkAllMasterKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkAllMasterKeys(context, callback, cookie, false);
                        }

                        public void end_RemoveThreadNetworkAllMasterKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveThreadNetworkAllMasterKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys> begin_RemoveThreadNetworkAllMasterKeys(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkAllMasterKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveThreadNetworkAllMasterKeys_name, cookie, completedCallback);
                            _iceI_RemoveThreadNetworkAllMasterKeys(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys> begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveThreadNetworkMasterKeys(panId, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkMasterKeys(panId, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKeys(int panId, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkMasterKeys(panId, context, callback, cookie, false);
                        }

                        public void end_RemoveThreadNetworkMasterKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveThreadNetworkMasterKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys> begin_RemoveThreadNetworkMasterKeys(int iceP_panId, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveThreadNetworkMasterKeys_name, cookie, completedCallback);
                            _iceI_RemoveThreadNetworkMasterKeys(iceP_panId, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey> begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveThreadNetworkMasterKey(panId, key128, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkMasterKey(panId, key128, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveThreadNetworkMasterKey(panId, key128, context, callback, cookie, false);
                        }

                        public void end_RemoveThreadNetworkMasterKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveThreadNetworkMasterKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey> begin_RemoveThreadNetworkMasterKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveThreadNetworkMasterKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveThreadNetworkMasterKey_name, cookie, completedCallback);
                            _iceI_RemoveThreadNetworkMasterKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey> begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AddZigbeeApsKey(destinationAddress64, sourceAddress64, key128, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddZigbeeApsKey(destinationAddress64, sourceAddress64, key128, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddZigbeeApsKey(destinationAddress64, sourceAddress64, key128, context, callback, cookie, false);
                        }

                        public void end_AddZigbeeApsKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AddZigbeeApsKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey> begin_AddZigbeeApsKey(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_AddZigbeeApsKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AddZigbeeApsKey_name, cookie, completedCallback);
                            _iceI_AddZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys> begin_RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeApsAllKeys(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsAllKeys(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsAllKeys(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsAllKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsAllKeys(context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeApsAllKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeApsAllKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys> begin_RemoveZigbeeApsAllKeys(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsAllKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeApsAllKeys_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeApsAllKeys(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys> begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeApsKeys(destinationAddress64, sourceAddress64, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsKeys(destinationAddress64, sourceAddress64, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsKeys(destinationAddress64, sourceAddress64, context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeApsKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeApsKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys> begin_RemoveZigbeeApsKeys(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeApsKeys_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeApsKeys(iceP_destinationAddress64, iceP_sourceAddress64, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey> begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeApsKey(destinationAddress64, sourceAddress64, key128, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsKey(destinationAddress64, sourceAddress64, key128, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeApsKey(destinationAddress64, sourceAddress64, key128, context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeApsKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeApsKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey> begin_RemoveZigbeeApsKey(byte[] iceP_destinationAddress64, byte[] iceP_sourceAddress64, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeApsKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeApsKey_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey> begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_AddZigbeeNetworkKey(panId, key128, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddZigbeeNetworkKey(panId, key128, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_AddZigbeeNetworkKey(panId, key128, context, callback, cookie, false);
                        }

                        public void end_AddZigbeeNetworkKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _AddZigbeeNetworkKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey> begin_AddZigbeeNetworkKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_AddZigbeeNetworkKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _AddZigbeeNetworkKey_name, cookie, completedCallback);
                            _iceI_AddZigbeeNetworkKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys> begin_RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeNetworkAllKeys(context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkAllKeys(global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkAllKeys(new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkAllKeys(global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkAllKeys(context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeNetworkAllKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeNetworkAllKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys> begin_RemoveZigbeeNetworkAllKeys(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkAllKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeNetworkAllKeys_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeNetworkAllKeys(context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys> begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeNetworkKeys(panId, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkKeys(panId, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkKeys(int panId, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkKeys(panId, context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeNetworkKeys(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeNetworkKeys_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys> begin_RemoveZigbeeNetworkKeys(int iceP_panId, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKeys cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeNetworkKeys_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeNetworkKeys(iceP_panId, context, synchronous, completed);
                            return completed;
                        }

                        public global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey> begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                        {
                            return begin_RemoveZigbeeNetworkKey(panId, key128, context, null, null, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkKey(panId, key128, new global::Ice.OptionalContext(), callback, cookie, false);
                        }

                        public global::Ice.AsyncResult begin_RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                        {
                            return begin_RemoveZigbeeNetworkKey(panId, key128, context, callback, cookie, false);
                        }

                        public void end_RemoveZigbeeNetworkKey(global::Ice.AsyncResult asyncResult)
                        {
                            var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _RemoveZigbeeNetworkKey_name);
                            ((global::IceInternal.OutgoingAsyncT<object>)resultI_.OutgoingAsync).getResult(resultI_.wait());
                        }

                        private global::Ice.AsyncResult<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey> begin_RemoveZigbeeNetworkKey(int iceP_panId, byte[] iceP_key128, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                        {
                            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey, object>(
                                (Callback_WpanAnalyzerRemoteControl_RemoveZigbeeNetworkKey cb, object ret) =>
                                {
                                    if(cb != null)
                                    {
                                        cb.Invoke();
                                    }
                                },
                                this, _RemoveZigbeeNetworkKey_name, cookie, completedCallback);
                            _iceI_RemoveZigbeeNetworkKey(iceP_panId, iceP_key128, context, synchronous, completed);
                            return completed;
                        }

                        #endregion

                        #region Checked and unchecked cast operations

                        public static WpanAnalyzerRemoteControlPrx checkedCast(global::Ice.ObjectPrx b)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            WpanAnalyzerRemoteControlPrx r = b as WpanAnalyzerRemoteControlPrx;
                            if((r == null) && b.ice_isA(ice_staticId()))
                            {
                                WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                                h.iceCopyFrom(b);
                                r = h;
                            }
                            return r;
                        }

                        public static WpanAnalyzerRemoteControlPrx checkedCast(global::Ice.ObjectPrx b, global::System.Collections.Generic.Dictionary<string, string> ctx)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            WpanAnalyzerRemoteControlPrx r = b as WpanAnalyzerRemoteControlPrx;
                            if((r == null) && b.ice_isA(ice_staticId(), ctx))
                            {
                                WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                                h.iceCopyFrom(b);
                                r = h;
                            }
                            return r;
                        }

                        public static WpanAnalyzerRemoteControlPrx checkedCast(global::Ice.ObjectPrx b, string f)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            global::Ice.ObjectPrx bb = b.ice_facet(f);
                            try
                            {
                                if(bb.ice_isA(ice_staticId()))
                                {
                                    WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                                    h.iceCopyFrom(bb);
                                    return h;
                                }
                            }
                            catch(global::Ice.FacetNotExistException)
                            {
                            }
                            return null;
                        }

                        public static WpanAnalyzerRemoteControlPrx checkedCast(global::Ice.ObjectPrx b, string f, global::System.Collections.Generic.Dictionary<string, string> ctx)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            global::Ice.ObjectPrx bb = b.ice_facet(f);
                            try
                            {
                                if(bb.ice_isA(ice_staticId(), ctx))
                                {
                                    WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                                    h.iceCopyFrom(bb);
                                    return h;
                                }
                            }
                            catch(global::Ice.FacetNotExistException)
                            {
                            }
                            return null;
                        }

                        public static WpanAnalyzerRemoteControlPrx uncheckedCast(global::Ice.ObjectPrx b)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            WpanAnalyzerRemoteControlPrx r = b as WpanAnalyzerRemoteControlPrx;
                            if(r == null)
                            {
                                WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                                h.iceCopyFrom(b);
                                r = h;
                            }
                            return r;
                        }

                        public static WpanAnalyzerRemoteControlPrx uncheckedCast(global::Ice.ObjectPrx b, string f)
                        {
                            if(b == null)
                            {
                                return null;
                            }
                            global::Ice.ObjectPrx bb = b.ice_facet(f);
                            WpanAnalyzerRemoteControlPrxHelper h = new WpanAnalyzerRemoteControlPrxHelper();
                            h.iceCopyFrom(bb);
                            return h;
                        }

                        private static readonly string[] _ids =
                        {
                            "::Ellisys::Platform::NetworkRemoteControl::Analyzer::AnalyzerRemoteControl",
                            "::Ellisys::Platform::NetworkRemoteControl::Analyzer::Wpan::WpanAnalyzerRemoteControl",
                            "::Ice::Object"
                        };

                        public static string ice_staticId()
                        {
                            return _ids[1];
                        }

                        #endregion

                        #region Marshaling support

                        public static void write(global::Ice.OutputStream ostr, WpanAnalyzerRemoteControlPrx v)
                        {
                            ostr.writeProxy(v);
                        }

                        public static WpanAnalyzerRemoteControlPrx read(global::Ice.InputStream istr)
                        {
                            global::Ice.ObjectPrx proxy = istr.readProxy();
                            if(proxy != null)
                            {
                                WpanAnalyzerRemoteControlPrxHelper result = new WpanAnalyzerRemoteControlPrxHelper();
                                result.iceCopyFrom(proxy);
                                return result;
                            }
                            return null;
                        }

                        #endregion
                    }
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                namespace Wpan
                {
                    [global::System.Runtime.InteropServices.ComVisible(false)]
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public abstract class WpanAnalyzerRemoteControlDisp_ : global::Ice.ObjectImpl, WpanAnalyzerRemoteControl
                    {
                        #region Slice operations

                        public abstract void AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.Current current = null);

                        public abstract void RemoveThreadNetworkAllMasterKeys(global::Ice.Current current = null);

                        public abstract void RemoveThreadNetworkMasterKeys(int panId, global::Ice.Current current = null);

                        public abstract void RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.Current current = null);

                        public abstract void AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null);

                        public abstract void RemoveZigbeeApsAllKeys(global::Ice.Current current = null);

                        public abstract void RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.Current current = null);

                        public abstract void RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null);

                        public abstract void AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null);

                        public abstract void RemoveZigbeeNetworkAllKeys(global::Ice.Current current = null);

                        public abstract void RemoveZigbeeNetworkKeys(int panId, global::Ice.Current current = null);

                        public abstract void RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null);

                        #endregion

                        #region Inherited Slice operations

                        public abstract void AbortRecordingAndDiscardTraceFile(global::Ice.Current current = null);

                        public abstract void AbortRunningTask(string name, global::Ice.Current current = null);

                        public abstract void AddMarkerAtTime(long timeInPicoseconds, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.Current current = null);

                        public abstract void AddMarkerOnSelectedOverviewItem(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AddMarker marker, global::Ice.Current current = null);

                        public abstract void CancelUserInteraction(global::Ice.Current current = null);

                        public abstract void CloseTraceFile(global::Ice.Current current = null);

                        public abstract void ConfigureRecordingOptions(string options, global::Ice.Current current = null);

                        public abstract void ConfigureSettings(byte[] settings, global::Ice.Current current = null);

                        public abstract void ExitApp(global::Ice.Current current = null);

                        public abstract void Export(string outputFilename, string exportName, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.ExportOption[] exportOptions, global::Ice.Current current = null);

                        public abstract void FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, global::Ellisys.Platform.NetworkRemoteControl.Analyzer.LogicSignalTransitionType transitionType, out int foundLogicSignalsState, out long foundTimeInPicoseconds, global::Ice.Current current = null);

                        public abstract global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AppInfo GetAppInfo(global::Ice.Current current = null);

                        public abstract string[] GetAvailableDataSources(global::Ice.Current current = null);

                        public abstract string[] GetAvailableOverviews(global::Ice.Current current = null);

                        public abstract string[] GetAvailableProtocolLayers(global::Ice.Current current = null);

                        public abstract void GetLogicSignalsState(long timeInPicoseconds, out int logicSignalsState, global::Ice.Current current = null);

                        public abstract global::Ellisys.Platform.NetworkRemoteControl.Analyzer.GetMarker[] GetMarkers(global::Ice.Current current = null);

                        public abstract int GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.Current current = null);

                        public abstract int GetOverviewItemChildCount(int itemHandle, global::Ice.Current current = null);

                        public abstract int[] GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.Current current = null);

                        public abstract byte[] GetOverviewItemData(int itemHandle, global::Ice.Current current = null);

                        public abstract string GetOverviewItemDescription(int itemHandle, global::Ice.Current current = null);

                        public abstract long GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.Current current = null);

                        public abstract string GetOverviewItemXmlReport(int itemHandle, global::Ice.Current current = null);

                        public abstract string GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.Current current = null);

                        public abstract byte[][] GetOverviewItemsData(int[] itemHandles, global::Ice.Current current = null);

                        public abstract string[] GetOverviewItemsDescription(int[] itemHandles, global::Ice.Current current = null);

                        public abstract long[] GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.Current current = null);

                        public abstract string[] GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.Current current = null);

                        public abstract string[] GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.Current current = null);

                        public abstract string GetOverviewQuery(global::Ice.Current current = null);

                        public abstract string GetRecordingOptions(bool relevantOnly, global::Ice.Current current = null);

                        public abstract global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RecordingStatus GetRecordingStatus(global::Ice.Current current = null);

                        public abstract global::Ellisys.Platform.NetworkRemoteControl.Analyzer.RunningTask[] GetRunningTasks(global::Ice.Current current = null);

                        public abstract string GetSelectedDataSource(global::Ice.Current current = null);

                        public abstract string GetSelectedOverview(global::Ice.Current current = null);

                        public abstract int GetSelectedOverviewItem(global::Ice.Current current = null);

                        public abstract string GetSelectedProtocolLayer(global::Ice.Current current = null);

                        public abstract byte[] GetSettings(global::Ice.Current current = null);

                        public abstract global::Ellisys.Platform.NetworkRemoteControl.Analyzer.TraceFileInfo GetTraceFileInfo(global::Ice.Current current = null);

                        public abstract void InsertComment(string comment, string overviewName, global::Ice.Current current = null);

                        public abstract void InsertMessage(global::Ellisys.Platform.NetworkRemoteControl.Analyzer.MessageSeverity severity, string message, global::Ice.Current current = null);

                        public abstract bool IsLoading(global::Ice.Current current = null);

                        public abstract bool IsModified(global::Ice.Current current = null);

                        public abstract bool IsRecording(global::Ice.Current current = null);

                        public abstract int OverviewRootItem(global::Ice.Current current = null);

                        public abstract void ReleaseAllOverviewItemHandles(global::Ice.Current current = null);

                        public abstract void SaveChanges(global::Ice.Current current = null);

                        public abstract int[] SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.Current current = null);

                        public abstract void SelectDataSource(string dataSourceUniqueId, global::Ice.Current current = null);

                        public abstract void SelectOverview(string overviewName, global::Ice.Current current = null);

                        public abstract void SelectOverviewItem(int itemHandle, global::Ice.Current current = null);

                        public abstract void SelectProtocolLayer(string protocolLayerName, global::Ice.Current current = null);

                        public abstract void SetOverviewQuery(string query, global::Ice.Current current = null);

                        public abstract void StartLoading(string filename, global::Ice.Current current = null);

                        public abstract void StartRecording(global::Ice.Current current = null);

                        public abstract void StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.Current current = null);

                        #endregion

                        #region Slice type-related members

                        private static readonly string[] _ids =
                        {
                            "::Ellisys::Platform::NetworkRemoteControl::Analyzer::AnalyzerRemoteControl",
                            "::Ellisys::Platform::NetworkRemoteControl::Analyzer::Wpan::WpanAnalyzerRemoteControl",
                            "::Ice::Object"
                        };

                        public override bool ice_isA(string s, global::Ice.Current current = null)
                        {
                            return global::System.Array.BinarySearch(_ids, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
                        }

                        public override string[] ice_ids(global::Ice.Current current = null)
                        {
                            return _ids;
                        }

                        public override string ice_id(global::Ice.Current current = null)
                        {
                            return _ids[1];
                        }

                        public static new string ice_staticId()
                        {
                            return _ids[1];
                        }

                        #endregion

                        #region Operation dispatch

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_AddThreadNetworkMasterKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            byte[] iceP_key128;
                            long iceP_sequenceCounter;
                            iceP_panId = istr.readInt();
                            iceP_key128 = ByteArrayHelper.read(istr);
                            iceP_sequenceCounter = istr.readLong();
                            inS.endReadParams();
                            obj.AddThreadNetworkMasterKey(iceP_panId, iceP_key128, iceP_sequenceCounter, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveThreadNetworkAllMasterKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            inS.readEmptyParams();
                            obj.RemoveThreadNetworkAllMasterKeys(current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveThreadNetworkMasterKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            iceP_panId = istr.readInt();
                            inS.endReadParams();
                            obj.RemoveThreadNetworkMasterKeys(iceP_panId, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveThreadNetworkMasterKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            byte[] iceP_key128;
                            iceP_panId = istr.readInt();
                            iceP_key128 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.RemoveThreadNetworkMasterKey(iceP_panId, iceP_key128, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_AddZigbeeApsKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            byte[] iceP_destinationAddress64;
                            byte[] iceP_sourceAddress64;
                            byte[] iceP_key128;
                            iceP_destinationAddress64 = ByteArrayHelper.read(istr);
                            iceP_sourceAddress64 = ByteArrayHelper.read(istr);
                            iceP_key128 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.AddZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeApsAllKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            inS.readEmptyParams();
                            obj.RemoveZigbeeApsAllKeys(current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeApsKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            byte[] iceP_destinationAddress64;
                            byte[] iceP_sourceAddress64;
                            iceP_destinationAddress64 = ByteArrayHelper.read(istr);
                            iceP_sourceAddress64 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.RemoveZigbeeApsKeys(iceP_destinationAddress64, iceP_sourceAddress64, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeApsKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            byte[] iceP_destinationAddress64;
                            byte[] iceP_sourceAddress64;
                            byte[] iceP_key128;
                            iceP_destinationAddress64 = ByteArrayHelper.read(istr);
                            iceP_sourceAddress64 = ByteArrayHelper.read(istr);
                            iceP_key128 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.RemoveZigbeeApsKey(iceP_destinationAddress64, iceP_sourceAddress64, iceP_key128, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_AddZigbeeNetworkKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            byte[] iceP_key128;
                            iceP_panId = istr.readInt();
                            iceP_key128 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.AddZigbeeNetworkKey(iceP_panId, iceP_key128, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeNetworkAllKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            inS.readEmptyParams();
                            obj.RemoveZigbeeNetworkAllKeys(current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeNetworkKeys(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            iceP_panId = istr.readInt();
                            inS.endReadParams();
                            obj.RemoveZigbeeNetworkKeys(iceP_panId, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                        public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceD_RemoveZigbeeNetworkKey(WpanAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                            var istr = inS.startReadParams();
                            int iceP_panId;
                            byte[] iceP_key128;
                            iceP_panId = istr.readInt();
                            iceP_key128 = ByteArrayHelper.read(istr);
                            inS.endReadParams();
                            obj.RemoveZigbeeNetworkKey(iceP_panId, iceP_key128, current);
                            return inS.setResult(inS.writeEmptyParams());
                        }

                        private static readonly string[] _all =
                        {
                            "AbortRecordingAndDiscardTraceFile",
                            "AbortRunningTask",
                            "AddMarkerAtTime",
                            "AddMarkerOnSelectedOverviewItem",
                            "AddThreadNetworkMasterKey",
                            "AddZigbeeApsKey",
                            "AddZigbeeNetworkKey",
                            "CancelUserInteraction",
                            "CloseTraceFile",
                            "ConfigureRecordingOptions",
                            "ConfigureSettings",
                            "ExitApp",
                            "Export",
                            "FindLogicSignalsTransition",
                            "GetAppInfo",
                            "GetAvailableDataSources",
                            "GetAvailableOverviews",
                            "GetAvailableProtocolLayers",
                            "GetLogicSignalsState",
                            "GetMarkers",
                            "GetOverviewItemChild",
                            "GetOverviewItemChildCount",
                            "GetOverviewItemChildren",
                            "GetOverviewItemData",
                            "GetOverviewItemDescription",
                            "GetOverviewItemTimeInPicoseconds",
                            "GetOverviewItemXmlReport",
                            "GetOverviewItemXmlReportFiltered",
                            "GetOverviewItemsData",
                            "GetOverviewItemsDescription",
                            "GetOverviewItemsTimeInPicoseconds",
                            "GetOverviewItemsXmlReport",
                            "GetOverviewItemsXmlReportFiltered",
                            "GetOverviewQuery",
                            "GetRecordingOptions",
                            "GetRecordingStatus",
                            "GetRunningTasks",
                            "GetSelectedDataSource",
                            "GetSelectedOverview",
                            "GetSelectedOverviewItem",
                            "GetSelectedProtocolLayer",
                            "GetSettings",
                            "GetTraceFileInfo",
                            "InsertComment",
                            "InsertMessage",
                            "IsLoading",
                            "IsModified",
                            "IsRecording",
                            "OverviewRootItem",
                            "ReleaseAllOverviewItemHandles",
                            "RemoveThreadNetworkAllMasterKeys",
                            "RemoveThreadNetworkMasterKey",
                            "RemoveThreadNetworkMasterKeys",
                            "RemoveZigbeeApsAllKeys",
                            "RemoveZigbeeApsKey",
                            "RemoveZigbeeApsKeys",
                            "RemoveZigbeeNetworkAllKeys",
                            "RemoveZigbeeNetworkKey",
                            "RemoveZigbeeNetworkKeys",
                            "SaveChanges",
                            "SearchOverviewItems",
                            "SelectDataSource",
                            "SelectOverview",
                            "SelectOverviewItem",
                            "SelectProtocolLayer",
                            "SetOverviewQuery",
                            "StartLoading",
                            "StartRecording",
                            "StopRecordingAndSaveTraceFile",
                            "ice_id",
                            "ice_ids",
                            "ice_isA",
                            "ice_ping"
                        };

                        public override global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                        iceDispatch(global::IceInternal.Incoming inS, global::Ice.Current current)
                        {
                            int pos = global::System.Array.BinarySearch(_all, current.operation, global::IceUtilInternal.StringUtil.OrdinalStringComparer);
                            if(pos < 0)
                            {
                                throw new global::Ice.OperationNotExistException(current.id, current.facet, current.operation);
                            }

                            switch(pos)
                            {
                                case 0:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_AbortRecordingAndDiscardTraceFile(this, inS, current);
                                }
                                case 1:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_AbortRunningTask(this, inS, current);
                                }
                                case 2:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_AddMarkerAtTime(this, inS, current);
                                }
                                case 3:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_AddMarkerOnSelectedOverviewItem(this, inS, current);
                                }
                                case 4:
                                {
                                    return iceD_AddThreadNetworkMasterKey(this, inS, current);
                                }
                                case 5:
                                {
                                    return iceD_AddZigbeeApsKey(this, inS, current);
                                }
                                case 6:
                                {
                                    return iceD_AddZigbeeNetworkKey(this, inS, current);
                                }
                                case 7:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_CancelUserInteraction(this, inS, current);
                                }
                                case 8:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_CloseTraceFile(this, inS, current);
                                }
                                case 9:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_ConfigureRecordingOptions(this, inS, current);
                                }
                                case 10:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_ConfigureSettings(this, inS, current);
                                }
                                case 11:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_ExitApp(this, inS, current);
                                }
                                case 12:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_Export(this, inS, current);
                                }
                                case 13:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_FindLogicSignalsTransition(this, inS, current);
                                }
                                case 14:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetAppInfo(this, inS, current);
                                }
                                case 15:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetAvailableDataSources(this, inS, current);
                                }
                                case 16:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetAvailableOverviews(this, inS, current);
                                }
                                case 17:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetAvailableProtocolLayers(this, inS, current);
                                }
                                case 18:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetLogicSignalsState(this, inS, current);
                                }
                                case 19:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetMarkers(this, inS, current);
                                }
                                case 20:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChild(this, inS, current);
                                }
                                case 21:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChildCount(this, inS, current);
                                }
                                case 22:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChildren(this, inS, current);
                                }
                                case 23:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemData(this, inS, current);
                                }
                                case 24:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemDescription(this, inS, current);
                                }
                                case 25:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemTimeInPicoseconds(this, inS, current);
                                }
                                case 26:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemXmlReport(this, inS, current);
                                }
                                case 27:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemXmlReportFiltered(this, inS, current);
                                }
                                case 28:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsData(this, inS, current);
                                }
                                case 29:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsDescription(this, inS, current);
                                }
                                case 30:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsTimeInPicoseconds(this, inS, current);
                                }
                                case 31:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsXmlReport(this, inS, current);
                                }
                                case 32:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsXmlReportFiltered(this, inS, current);
                                }
                                case 33:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetOverviewQuery(this, inS, current);
                                }
                                case 34:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetRecordingOptions(this, inS, current);
                                }
                                case 35:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetRecordingStatus(this, inS, current);
                                }
                                case 36:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetRunningTasks(this, inS, current);
                                }
                                case 37:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetSelectedDataSource(this, inS, current);
                                }
                                case 38:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetSelectedOverview(this, inS, current);
                                }
                                case 39:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetSelectedOverviewItem(this, inS, current);
                                }
                                case 40:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetSelectedProtocolLayer(this, inS, current);
                                }
                                case 41:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetSettings(this, inS, current);
                                }
                                case 42:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_GetTraceFileInfo(this, inS, current);
                                }
                                case 43:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_InsertComment(this, inS, current);
                                }
                                case 44:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_InsertMessage(this, inS, current);
                                }
                                case 45:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_IsLoading(this, inS, current);
                                }
                                case 46:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_IsModified(this, inS, current);
                                }
                                case 47:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_IsRecording(this, inS, current);
                                }
                                case 48:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_OverviewRootItem(this, inS, current);
                                }
                                case 49:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_ReleaseAllOverviewItemHandles(this, inS, current);
                                }
                                case 50:
                                {
                                    return iceD_RemoveThreadNetworkAllMasterKeys(this, inS, current);
                                }
                                case 51:
                                {
                                    return iceD_RemoveThreadNetworkMasterKey(this, inS, current);
                                }
                                case 52:
                                {
                                    return iceD_RemoveThreadNetworkMasterKeys(this, inS, current);
                                }
                                case 53:
                                {
                                    return iceD_RemoveZigbeeApsAllKeys(this, inS, current);
                                }
                                case 54:
                                {
                                    return iceD_RemoveZigbeeApsKey(this, inS, current);
                                }
                                case 55:
                                {
                                    return iceD_RemoveZigbeeApsKeys(this, inS, current);
                                }
                                case 56:
                                {
                                    return iceD_RemoveZigbeeNetworkAllKeys(this, inS, current);
                                }
                                case 57:
                                {
                                    return iceD_RemoveZigbeeNetworkKey(this, inS, current);
                                }
                                case 58:
                                {
                                    return iceD_RemoveZigbeeNetworkKeys(this, inS, current);
                                }
                                case 59:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SaveChanges(this, inS, current);
                                }
                                case 60:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SearchOverviewItems(this, inS, current);
                                }
                                case 61:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SelectDataSource(this, inS, current);
                                }
                                case 62:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SelectOverview(this, inS, current);
                                }
                                case 63:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SelectOverviewItem(this, inS, current);
                                }
                                case 64:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SelectProtocolLayer(this, inS, current);
                                }
                                case 65:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_SetOverviewQuery(this, inS, current);
                                }
                                case 66:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_StartLoading(this, inS, current);
                                }
                                case 67:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_StartRecording(this, inS, current);
                                }
                                case 68:
                                {
                                    return global::Ellisys.Platform.NetworkRemoteControl.Analyzer.AnalyzerRemoteControlDisp_.iceD_StopRecordingAndSaveTraceFile(this, inS, current);
                                }
                                case 69:
                                {
                                    return global::Ice.ObjectImpl.iceD_ice_id(this, inS, current);
                                }
                                case 70:
                                {
                                    return global::Ice.ObjectImpl.iceD_ice_ids(this, inS, current);
                                }
                                case 71:
                                {
                                    return global::Ice.ObjectImpl.iceD_ice_isA(this, inS, current);
                                }
                                case 72:
                                {
                                    return global::Ice.ObjectImpl.iceD_ice_ping(this, inS, current);
                                }
                            }

                            global::System.Diagnostics.Debug.Assert(false);
                            throw new global::Ice.OperationNotExistException(current.id, current.facet, current.operation);
                        }

                        #endregion
                    }

                    [global::System.Runtime.InteropServices.ComVisible(false)]
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public class WpanAnalyzerRemoteControlTie_ : WpanAnalyzerRemoteControlDisp_, global::Ice.TieBase
                    {
                        public WpanAnalyzerRemoteControlTie_()
                        {
                        }

                        public WpanAnalyzerRemoteControlTie_(WpanAnalyzerRemoteControlOperations_ del)
                        {
                            _ice_delegate = del;
                        }

                        public object ice_delegate()
                        {
                            return _ice_delegate;
                        }

                        public void ice_delegate(object del)
                        {
                            _ice_delegate = (WpanAnalyzerRemoteControlOperations_)del;
                        }

                        public override int GetHashCode()
                        {
                            return _ice_delegate == null ? 0 : _ice_delegate.GetHashCode();
                        }

                        public override bool Equals(object rhs)
                        {
                            if(object.ReferenceEquals(this, rhs))
                            {
                                return true;
                            }
                            if(!(rhs is WpanAnalyzerRemoteControlTie_))
                            {
                                return false;
                            }
                            if(_ice_delegate == null)
                            {
                                return ((WpanAnalyzerRemoteControlTie_)rhs)._ice_delegate == null;
                            }
                            return _ice_delegate.Equals(((WpanAnalyzerRemoteControlTie_)rhs)._ice_delegate);
                        }

                        public override void AddThreadNetworkMasterKey(int panId, byte[] key128, long sequenceCounter, global::Ice.Current current = null)
                        {
                            _ice_delegate.AddThreadNetworkMasterKey(panId, key128, sequenceCounter, current);
                        }

                        public override void RemoveThreadNetworkAllMasterKeys(global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveThreadNetworkAllMasterKeys(current);
                        }

                        public override void RemoveThreadNetworkMasterKeys(int panId, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveThreadNetworkMasterKeys(panId, current);
                        }

                        public override void RemoveThreadNetworkMasterKey(int panId, byte[] key128, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveThreadNetworkMasterKey(panId, key128, current);
                        }

                        public override void AddZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null)
                        {
                            _ice_delegate.AddZigbeeApsKey(destinationAddress64, sourceAddress64, key128, current);
                        }

                        public override void RemoveZigbeeApsAllKeys(global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeApsAllKeys(current);
                        }

                        public override void RemoveZigbeeApsKeys(byte[] destinationAddress64, byte[] sourceAddress64, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeApsKeys(destinationAddress64, sourceAddress64, current);
                        }

                        public override void RemoveZigbeeApsKey(byte[] destinationAddress64, byte[] sourceAddress64, byte[] key128, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeApsKey(destinationAddress64, sourceAddress64, key128, current);
                        }

                        public override void AddZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null)
                        {
                            _ice_delegate.AddZigbeeNetworkKey(panId, key128, current);
                        }

                        public override void RemoveZigbeeNetworkAllKeys(global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeNetworkAllKeys(current);
                        }

                        public override void RemoveZigbeeNetworkKeys(int panId, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeNetworkKeys(panId, current);
                        }

                        public override void RemoveZigbeeNetworkKey(int panId, byte[] key128, global::Ice.Current current = null)
                        {
                            _ice_delegate.RemoveZigbeeNetworkKey(panId, key128, current);
                        }

                        public override AppInfo GetAppInfo(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetAppInfo(current);
                        }

                        public override void ExitApp(global::Ice.Current current = null)
                        {
                            _ice_delegate.ExitApp(current);
                        }

                        public override string[] GetAvailableDataSources(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetAvailableDataSources(current);
                        }

                        public override void SelectDataSource(string dataSourceUniqueId, global::Ice.Current current = null)
                        {
                            _ice_delegate.SelectDataSource(dataSourceUniqueId, current);
                        }

                        public override string GetSelectedDataSource(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetSelectedDataSource(current);
                        }

                        public override bool IsRecording(global::Ice.Current current = null)
                        {
                            return _ice_delegate.IsRecording(current);
                        }

                        public override RecordingStatus GetRecordingStatus(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetRecordingStatus(current);
                        }

                        public override void StartRecording(global::Ice.Current current = null)
                        {
                            _ice_delegate.StartRecording(current);
                        }

                        public override void StopRecordingAndSaveTraceFile(string filename, bool overwrite, global::Ice.Current current = null)
                        {
                            _ice_delegate.StopRecordingAndSaveTraceFile(filename, overwrite, current);
                        }

                        public override void AbortRecordingAndDiscardTraceFile(global::Ice.Current current = null)
                        {
                            _ice_delegate.AbortRecordingAndDiscardTraceFile(current);
                        }

                        public override string GetRecordingOptions(bool relevantOnly, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetRecordingOptions(relevantOnly, current);
                        }

                        public override void ConfigureRecordingOptions(string options, global::Ice.Current current = null)
                        {
                            _ice_delegate.ConfigureRecordingOptions(options, current);
                        }

                        public override void InsertMessage(MessageSeverity severity, string message, global::Ice.Current current = null)
                        {
                            _ice_delegate.InsertMessage(severity, message, current);
                        }

                        public override bool IsLoading(global::Ice.Current current = null)
                        {
                            return _ice_delegate.IsLoading(current);
                        }

                        public override void StartLoading(string filename, global::Ice.Current current = null)
                        {
                            _ice_delegate.StartLoading(filename, current);
                        }

                        public override TraceFileInfo GetTraceFileInfo(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetTraceFileInfo(current);
                        }

                        public override void CloseTraceFile(global::Ice.Current current = null)
                        {
                            _ice_delegate.CloseTraceFile(current);
                        }

                        public override bool IsModified(global::Ice.Current current = null)
                        {
                            return _ice_delegate.IsModified(current);
                        }

                        public override void SaveChanges(global::Ice.Current current = null)
                        {
                            _ice_delegate.SaveChanges(current);
                        }

                        public override void AddMarkerOnSelectedOverviewItem(AddMarker marker, global::Ice.Current current = null)
                        {
                            _ice_delegate.AddMarkerOnSelectedOverviewItem(marker, current);
                        }

                        public override void AddMarkerAtTime(long timeInPicoseconds, AddMarker marker, global::Ice.Current current = null)
                        {
                            _ice_delegate.AddMarkerAtTime(timeInPicoseconds, marker, current);
                        }

                        public override GetMarker[] GetMarkers(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetMarkers(current);
                        }

                        public override void Export(string outputFilename, string exportName, ExportOption[] exportOptions, global::Ice.Current current = null)
                        {
                            _ice_delegate.Export(outputFilename, exportName, exportOptions, current);
                        }

                        public override string[] GetAvailableOverviews(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetAvailableOverviews(current);
                        }

                        public override string GetSelectedOverview(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetSelectedOverview(current);
                        }

                        public override void SelectOverview(string overviewName, global::Ice.Current current = null)
                        {
                            _ice_delegate.SelectOverview(overviewName, current);
                        }

                        public override string[] GetAvailableProtocolLayers(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetAvailableProtocolLayers(current);
                        }

                        public override string GetSelectedProtocolLayer(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetSelectedProtocolLayer(current);
                        }

                        public override void SelectProtocolLayer(string protocolLayerName, global::Ice.Current current = null)
                        {
                            _ice_delegate.SelectProtocolLayer(protocolLayerName, current);
                        }

                        public override string GetOverviewQuery(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewQuery(current);
                        }

                        public override void SetOverviewQuery(string query, global::Ice.Current current = null)
                        {
                            _ice_delegate.SetOverviewQuery(query, current);
                        }

                        public override int OverviewRootItem(global::Ice.Current current = null)
                        {
                            return _ice_delegate.OverviewRootItem(current);
                        }

                        public override string GetOverviewItemDescription(int itemHandle, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemDescription(itemHandle, current);
                        }

                        public override string[] GetOverviewItemsDescription(int[] itemHandles, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemsDescription(itemHandles, current);
                        }

                        public override long GetOverviewItemTimeInPicoseconds(int itemHandle, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemTimeInPicoseconds(itemHandle, current);
                        }

                        public override long[] GetOverviewItemsTimeInPicoseconds(int[] itemHandles, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemsTimeInPicoseconds(itemHandles, current);
                        }

                        public override byte[] GetOverviewItemData(int itemHandle, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemData(itemHandle, current);
                        }

                        public override byte[][] GetOverviewItemsData(int[] itemHandles, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemsData(itemHandles, current);
                        }

                        public override string GetOverviewItemXmlReport(int itemHandle, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemXmlReport(itemHandle, current);
                        }

                        public override string[] GetOverviewItemsXmlReport(int[] itemHandles, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemsXmlReport(itemHandles, current);
                        }

                        public override string GetOverviewItemXmlReportFiltered(int itemHandle, string[] fieldNameFilters, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemXmlReportFiltered(itemHandle, fieldNameFilters, current);
                        }

                        public override string[] GetOverviewItemsXmlReportFiltered(int[] itemHandles, string[] fieldNameFilters, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemsXmlReportFiltered(itemHandles, fieldNameFilters, current);
                        }

                        public override int GetOverviewItemChildCount(int itemHandle, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemChildCount(itemHandle, current);
                        }

                        public override int GetOverviewItemChild(int itemHandle, int childIndex, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemChild(itemHandle, childIndex, current);
                        }

                        public override int[] GetOverviewItemChildren(int itemHandle, int childIndex, int childCount, global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetOverviewItemChildren(itemHandle, childIndex, childCount, current);
                        }

                        public override int[] SearchOverviewItems(int itemHandle, int childIndex, int childCount, int maxDepth, string[] descriptionFilters, string[] fieldNameFilters, string[] fieldValueFilters, global::Ice.Current current = null)
                        {
                            return _ice_delegate.SearchOverviewItems(itemHandle, childIndex, childCount, maxDepth, descriptionFilters, fieldNameFilters, fieldValueFilters, current);
                        }

                        public override void ReleaseAllOverviewItemHandles(global::Ice.Current current = null)
                        {
                            _ice_delegate.ReleaseAllOverviewItemHandles(current);
                        }

                        public override void SelectOverviewItem(int itemHandle, global::Ice.Current current = null)
                        {
                            _ice_delegate.SelectOverviewItem(itemHandle, current);
                        }

                        public override int GetSelectedOverviewItem(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetSelectedOverviewItem(current);
                        }

                        public override void GetLogicSignalsState(long timeInPicoseconds, out int logicSignalsState, global::Ice.Current current = null)
                        {
                            _ice_delegate.GetLogicSignalsState(timeInPicoseconds, out logicSignalsState, current);
                        }

                        public override void FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, LogicSignalTransitionType transitionType, out int foundLogicSignalsState, out long foundTimeInPicoseconds, global::Ice.Current current = null)
                        {
                            _ice_delegate.FindLogicSignalsTransition(fromTimeInPicoseconds, toTimeInPicoseconds, signalsMask, transitionType, out foundLogicSignalsState, out foundTimeInPicoseconds, current);
                        }

                        public override RunningTask[] GetRunningTasks(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetRunningTasks(current);
                        }

                        public override void AbortRunningTask(string name, global::Ice.Current current = null)
                        {
                            _ice_delegate.AbortRunningTask(name, current);
                        }

                        public override byte[] GetSettings(global::Ice.Current current = null)
                        {
                            return _ice_delegate.GetSettings(current);
                        }

                        public override void ConfigureSettings(byte[] settings, global::Ice.Current current = null)
                        {
                            _ice_delegate.ConfigureSettings(settings, current);
                        }

                        public override void CancelUserInteraction(global::Ice.Current current = null)
                        {
                            _ice_delegate.CancelUserInteraction(current);
                        }

                        public override void InsertComment(string comment, string overviewName, global::Ice.Current current = null)
                        {
                            _ice_delegate.InsertComment(comment, overviewName, current);
                        }

                        private WpanAnalyzerRemoteControlOperations_ _ice_delegate;
                    }
                }
            }
        }
    }
}
