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


#pragma warning disable 1591

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

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public enum DeviceFilterMode
                {
                    KeepAll,
                    ExcludeBackground,
                    KeepOnly,
                    KeepInvolving
                }

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public sealed class DeviceFilterModeHelper
                {
                    public static void write(global::Ice.OutputStream ostr, DeviceFilterMode v)
                    {
                        ostr.writeEnum((int)v, 3);
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public static DeviceFilterMode read(global::Ice.InputStream istr)
                    {
                        DeviceFilterMode v;
                        v = (DeviceFilterMode)istr.readEnum(3);
                        return v;
                    }
                }

                [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")]
                [global::System.Serializable]
                public partial struct ChannelSummary
                {
                    #region Slice data members

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public long Ok;

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public long Retransmitted;

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public long PayloadError;

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public long HeaderError;

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public long NotApplicable;

                    #endregion

                    partial void ice_initialize();

                    #region Constructor

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public ChannelSummary(long Ok, long Retransmitted, long PayloadError, long HeaderError, long NotApplicable)
                    {
                        this.Ok = Ok;
                        this.Retransmitted = Retransmitted;
                        this.PayloadError = PayloadError;
                        this.HeaderError = HeaderError;
                        this.NotApplicable = NotApplicable;
                        ice_initialize();
                    }

                    #endregion

                    #region Object members

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public override int GetHashCode()
                    {
                        int h_ = 5381;
                        global::IceInternal.HashUtil.hashAdd(ref h_, "::Ellisys::Platform::NetworkRemoteControl::Analyzer::ChannelSummary");
                        global::IceInternal.HashUtil.hashAdd(ref h_, Ok);
                        global::IceInternal.HashUtil.hashAdd(ref h_, Retransmitted);
                        global::IceInternal.HashUtil.hashAdd(ref h_, PayloadError);
                        global::IceInternal.HashUtil.hashAdd(ref h_, HeaderError);
                        global::IceInternal.HashUtil.hashAdd(ref h_, NotApplicable);
                        return h_;
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public override bool Equals(object other)
                    {
                        if(!(other is ChannelSummary))
                        {
                            return false;
                        }
                        ChannelSummary o = (ChannelSummary)other;
                        if(!this.Ok.Equals(o.Ok))
                        {
                            return false;
                        }
                        if(!this.Retransmitted.Equals(o.Retransmitted))
                        {
                            return false;
                        }
                        if(!this.PayloadError.Equals(o.PayloadError))
                        {
                            return false;
                        }
                        if(!this.HeaderError.Equals(o.HeaderError))
                        {
                            return false;
                        }
                        if(!this.NotApplicable.Equals(o.NotApplicable))
                        {
                            return false;
                        }
                        return true;
                    }

                    #endregion

                    #region Comparison members

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public static bool operator==(ChannelSummary lhs, ChannelSummary rhs)
                    {
                        return Equals(lhs, rhs);
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public static bool operator!=(ChannelSummary lhs, ChannelSummary rhs)
                    {
                        return !Equals(lhs, rhs);
                    }

                    #endregion

                    #region Marshaling support

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public void ice_writeMembers(global::Ice.OutputStream ostr)
                    {
                        ostr.writeLong(this.Ok);
                        ostr.writeLong(this.Retransmitted);
                        ostr.writeLong(this.PayloadError);
                        ostr.writeLong(this.HeaderError);
                        ostr.writeLong(this.NotApplicable);
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public void ice_readMembers(global::Ice.InputStream istr)
                    {
                        this.Ok = istr.readLong();
                        this.Retransmitted = istr.readLong();
                        this.PayloadError = istr.readLong();
                        this.HeaderError = istr.readLong();
                        this.NotApplicable = istr.readLong();
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public static void ice_write(global::Ice.OutputStream ostr, ChannelSummary v)
                    {
                        v.ice_writeMembers(ostr);
                    }

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    public static ChannelSummary ice_read(global::Ice.InputStream istr)
                    {
                        var v = new ChannelSummary();
                        v.ice_readMembers(istr);
                        return v;
                    }

                    #endregion
                }

                [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 BluetoothAnalyzerRemoteControl : global::Ice.Object, BluetoothAnalyzerRemoteControlOperations_, AnalyzerRemoteControl
                {
                }
            }
        }
    }
}

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

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

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

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public delegate void Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssi(double rssi, long startTimeInPicoseconds, long stopTimeInPicoseconds);

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public delegate void Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange(double[] rssi, long startTimeInPicoseconds, long stopTimeInPicoseconds);

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

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

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                public struct BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult
                {
                    public BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult(double rssi, long startTimeInPicoseconds, long stopTimeInPicoseconds)
                    {
                        this.rssi = rssi;
                        this.startTimeInPicoseconds = startTimeInPicoseconds;
                        this.stopTimeInPicoseconds = stopTimeInPicoseconds;
                    }

                    public double rssi;
                    public long startTimeInPicoseconds;
                    public long stopTimeInPicoseconds;
                }

                public struct BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult
                {
                    public BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult(double[] rssi, long startTimeInPicoseconds, long stopTimeInPicoseconds)
                    {
                        this.rssi = rssi;
                        this.startTimeInPicoseconds = startTimeInPicoseconds;
                        this.stopTimeInPicoseconds = stopTimeInPicoseconds;
                    }

                    public double[] rssi;
                    public long startTimeInPicoseconds;
                    public long stopTimeInPicoseconds;
                }
            }
        }
    }
}

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public interface BluetoothAnalyzerRemoteControlPrx : AnalyzerRemoteControlPrx
                {
                    void SplitTraceFileAndContinueRecording(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task SplitTraceFileAndContinueRecordingAsync(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());

                    global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_SplitTraceFileAndContinueRecording> begin_SplitTraceFileAndContinueRecording(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_SplitTraceFileAndContinueRecording(string filename, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_SplitTraceFileAndContinueRecording(string filename, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

                    void AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task AddLinkKeyAsync(long bdaddr1, long bdaddr2, byte[] linkKey, 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_BluetoothAnalyzerRemoteControl_AddLinkKey> begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

                    void ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task ConfigureDeviceFilterAsync(DeviceFilterMode mode, long[] deviceAddrs, 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_BluetoothAnalyzerRemoteControl_ConfigureDeviceFilter> begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

                    void GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task<BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult> GetSpectrumRssiAsync(long timeInPicoseconds, int rfChannelNumber, 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_BluetoothAnalyzerRemoteControl_GetSpectrumRssi> begin_GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                    void end_GetSpectrumRssi(out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.AsyncResult asyncResult);

                    void GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult> GetSpectrumRssiRangeAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, 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_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange> begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                    void end_GetSpectrumRssiRange(out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.AsyncResult asyncResult);

                    ChannelSummary[] GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task<ChannelSummary[]> GetChannelsSummaryAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, 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_BluetoothAnalyzerRemoteControl_GetChannelsSummary> begin_GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

                    ChannelSummary[] end_GetChannelsSummary(global::Ice.AsyncResult asyncResult);

                    void ExportAudio(string outputDirectory, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::System.Threading.Tasks.Task ExportAudioAsync(string outputDirectory, 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_BluetoothAnalyzerRemoteControl_ExportAudio> begin_ExportAudio(string outputDirectory, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

                    global::Ice.AsyncResult begin_ExportAudio(string outputDirectory, global::Ice.AsyncCallback callback, object cookie);

                    global::Ice.AsyncResult begin_ExportAudio(string outputDirectory, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public interface BluetoothAnalyzerRemoteControlOperations_ : AnalyzerRemoteControlOperations_
                {
                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    void SplitTraceFileAndContinueRecording(string filename, global::Ice.Current current = null);

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    void AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.Current current = null);

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    void ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.Current current = null);

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    void GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null);

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    void GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null);

                    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                    ChannelSummary[] GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.Current current = null);

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

namespace Ellisys
{
    namespace Platform
    {
        namespace NetworkRemoteControl
        {
            namespace Analyzer
            {
                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public sealed class LinkKeyByteArrayHelper
                {
                    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.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public sealed class DeviceAddressArrayHelper
                {
                    public static void write(global::Ice.OutputStream ostr, long[] v)
                    {
                        ostr.writeLongSeq(v);
                    }

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

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public sealed class RssiArrayHelper
                {
                    public static void write(global::Ice.OutputStream ostr, double[] v)
                    {
                        ostr.writeDoubleSeq(v);
                    }

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

                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.2")]
                public sealed class ChannelsSummaryHelper
                {
                    public static void write(global::Ice.OutputStream ostr, ChannelSummary[] v)
                    {
                        if(v == null)
                        {
                            ostr.writeSize(0);
                        }
                        else
                        {
                            ostr.writeSize(v.Length);
                            for(int ix = 0; ix < v.Length; ++ix)
                            {
                                v[ix].ice_writeMembers(ostr);
                            }
                        }
                    }

                    public static ChannelSummary[] read(global::Ice.InputStream istr)
                    {
                        ChannelSummary[] v;
                        {
                            int szx = istr.readAndCheckSeqSize(40);
                            v = new ChannelSummary[szx];
                            for(int ix = 0; ix < szx; ++ix)
                            {
                                v[ix].ice_readMembers(istr);
                            }
                        }
                        return v;
                    }
                }

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

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

                    #region Synchronous operations

                    public 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 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(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 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(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, 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 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, 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, 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 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 SplitTraceFileAndContinueRecording(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            _iceI_SplitTraceFileAndContinueRecordingAsync(filename, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public void AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            _iceI_AddLinkKeyAsync(bdaddr1, bdaddr2, linkKey, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public void ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            _iceI_ConfigureDeviceFilterAsync(mode, deviceAddrs, context, null, global::System.Threading.CancellationToken.None, true).Wait();
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public void GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            var result_ = _iceI_GetSpectrumRssiAsync(timeInPicoseconds, rfChannelNumber, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            rssi = result_.rssi;
                            startTimeInPicoseconds = result_.startTimeInPicoseconds;
                            stopTimeInPicoseconds = result_.stopTimeInPicoseconds;
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public void GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            var result_ = _iceI_GetSpectrumRssiRangeAsync(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, context, null, global::System.Threading.CancellationToken.None, true).Result;
                            rssi = result_.rssi;
                            startTimeInPicoseconds = result_.startTimeInPicoseconds;
                            stopTimeInPicoseconds = result_.stopTimeInPicoseconds;
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public ChannelSummary[] GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            return _iceI_GetChannelsSummaryAsync(fromTimeInPicoseconds, toTimeInPicoseconds, context, null, global::System.Threading.CancellationToken.None, true).Result;
                        }
                        catch(global::System.AggregateException ex_)
                        {
                            throw ex_.InnerException;
                        }
                    }

                    public void ExportAudio(string outputDirectory, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        try
                        {
                            _iceI_ExportAudioAsync(outputDirectory, 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<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<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<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<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                AppInfo ret = null;
                                ret = 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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                bool ret;
                                ret = istr.readBool();
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task<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<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<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<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                RecordingStatus ret = null;
                                ret = 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(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(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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task InsertMessageAsync(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(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(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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task<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<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<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<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                TraceFileInfo ret = null;
                                ret = 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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task AddMarkerOnSelectedOverviewItemAsync(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(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(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) =>
                            {
                                AddMarker.ice_write(ostr, iceP_marker);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task AddMarkerAtTimeAsync(long timeInPicoseconds, 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, 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, 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);
                                AddMarker.ice_write(ostr, iceP_marker);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task<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<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<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<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                GetMarker[] ret;
                                ret = GetMarkerArrayHelper.read(istr);
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task ExportAsync(string outputFilename, string exportName, 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, 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, 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);
                                ExportOptionArrayHelper.write(ostr, iceP_exportOptions);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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(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(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(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(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(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(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) =>
                            {
                                HandleArrayHelper.write(ostr, iceP_itemHandles);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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(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) =>
                            {
                                HandleArrayHelper.write(ostr, iceP_itemHandles);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                long[] ret;
                                ret = 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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                byte[] ret;
                                ret = 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) =>
                            {
                                HandleArrayHelper.write(ostr, iceP_itemHandles);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                byte[][] ret;
                                ret = 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(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) =>
                            {
                                HandleArrayHelper.write(ostr, iceP_itemHandles);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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);
                                StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(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) =>
                            {
                                HandleArrayHelper.write(ostr, iceP_itemHandles);
                                StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                string[] ret;
                                ret = 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(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                int[] ret;
                                ret = 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);
                                StringArrayHelper.write(ostr, iceP_descriptionFilters);
                                StringArrayHelper.write(ostr, iceP_fieldNameFilters);
                                StringArrayHelper.write(ostr, iceP_fieldValueFilters);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                int[] ret;
                                ret = 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(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(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(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(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<AnalyzerRemoteControl_FindLogicSignalsTransitionResult> FindLogicSignalsTransitionAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, 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<AnalyzerRemoteControl_FindLogicSignalsTransitionResult> _iceI_FindLogicSignalsTransitionAsync(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_signalsMask, 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<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, LogicSignalTransitionType iceP_transitionType, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                AnalyzerRemoteControl_FindLogicSignalsTransitionResult ret = new AnalyzerRemoteControl_FindLogicSignalsTransitionResult();
                                ret.foundLogicSignalsState = istr.readInt();
                                ret.foundTimeInPicoseconds = istr.readLong();
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task<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<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<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<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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                RunningTask[] ret;
                                ret = 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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                byte[] ret;
                                ret = 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) =>
                            {
                                ByteArrayHelper.write(ostr, iceP_settings);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(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(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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task SplitTraceFileAndContinueRecordingAsync(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_SplitTraceFileAndContinueRecordingAsync(filename, context, progress, cancel, false);
                    }

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

                    private const string _SplitTraceFileAndContinueRecording_name = "SplitTraceFileAndContinueRecording";

                    private void _iceI_SplitTraceFileAndContinueRecording(string iceP_filename, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<object>(completed);
                        outAsync.invoke(
                            _SplitTraceFileAndContinueRecording_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(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task AddLinkKeyAsync(long bdaddr1, long bdaddr2, byte[] linkKey, 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_AddLinkKeyAsync(bdaddr1, bdaddr2, linkKey, context, progress, cancel, false);
                    }

                    private global::System.Threading.Tasks.Task _iceI_AddLinkKeyAsync(long iceP_bdaddr1, long iceP_bdaddr2, byte[] iceP_linkKey, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                    {
                        iceCheckTwowayOnly(_AddLinkKey_name);
                        var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                        _iceI_AddLinkKey(iceP_bdaddr1, iceP_bdaddr2, iceP_linkKey, context, synchronous, completed);
                        return completed.Task;
                    }

                    private const string _AddLinkKey_name = "AddLinkKey";

                    private void _iceI_AddLinkKey(long iceP_bdaddr1, long iceP_bdaddr2, byte[] iceP_linkKey, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<object>(completed);
                        outAsync.invoke(
                            _AddLinkKey_name,
                            global::Ice.OperationMode.Normal,
                            global::Ice.FormatType.DefaultFormat,
                            context,
                            synchronous,
                            write: (global::Ice.OutputStream ostr) =>
                            {
                                ostr.writeLong(iceP_bdaddr1);
                                ostr.writeLong(iceP_bdaddr2);
                                LinkKeyByteArrayHelper.write(ostr, iceP_linkKey);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task ConfigureDeviceFilterAsync(DeviceFilterMode mode, long[] deviceAddrs, 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_ConfigureDeviceFilterAsync(mode, deviceAddrs, context, progress, cancel, false);
                    }

                    private global::System.Threading.Tasks.Task _iceI_ConfigureDeviceFilterAsync(DeviceFilterMode iceP_mode, long[] iceP_deviceAddrs, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                    {
                        iceCheckTwowayOnly(_ConfigureDeviceFilter_name);
                        var completed = new global::IceInternal.OperationTaskCompletionCallback<object>(progress, cancel);
                        _iceI_ConfigureDeviceFilter(iceP_mode, iceP_deviceAddrs, context, synchronous, completed);
                        return completed.Task;
                    }

                    private const string _ConfigureDeviceFilter_name = "ConfigureDeviceFilter";

                    private void _iceI_ConfigureDeviceFilter(DeviceFilterMode iceP_mode, long[] iceP_deviceAddrs, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<object>(completed);
                        outAsync.invoke(
                            _ConfigureDeviceFilter_name,
                            global::Ice.OperationMode.Normal,
                            global::Ice.FormatType.DefaultFormat,
                            context,
                            synchronous,
                            write: (global::Ice.OutputStream ostr) =>
                            {
                                ostr.writeEnum((int)iceP_mode, 3);
                                DeviceAddressArrayHelper.write(ostr, iceP_deviceAddrs);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            });
                    }

                    public global::System.Threading.Tasks.Task<BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult> GetSpectrumRssiAsync(long timeInPicoseconds, int rfChannelNumber, 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_GetSpectrumRssiAsync(timeInPicoseconds, rfChannelNumber, context, progress, cancel, false);
                    }

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

                    private const string _GetSpectrumRssi_name = "GetSpectrumRssi";

                    private void _iceI_GetSpectrumRssi(long iceP_timeInPicoseconds, int iceP_rfChannelNumber, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult>(completed);
                        outAsync.invoke(
                            _GetSpectrumRssi_name,
                            global::Ice.OperationMode.Normal,
                            global::Ice.FormatType.DefaultFormat,
                            context,
                            synchronous,
                            write: (global::Ice.OutputStream ostr) =>
                            {
                                ostr.writeLong(iceP_timeInPicoseconds);
                                ostr.writeInt(iceP_rfChannelNumber);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult ret = new BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult();
                                ret.rssi = istr.readDouble();
                                ret.startTimeInPicoseconds = istr.readLong();
                                ret.stopTimeInPicoseconds = istr.readLong();
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult> GetSpectrumRssiRangeAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, 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_GetSpectrumRssiRangeAsync(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, context, progress, cancel, false);
                    }

                    private global::System.Threading.Tasks.Task<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult> _iceI_GetSpectrumRssiRangeAsync(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_rfChannelNumber, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                    {
                        iceCheckTwowayOnly(_GetSpectrumRssiRange_name);
                        var completed = new global::IceInternal.OperationTaskCompletionCallback<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult>(progress, cancel);
                        _iceI_GetSpectrumRssiRange(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, iceP_rfChannelNumber, context, synchronous, completed);
                        return completed.Task;
                    }

                    private const string _GetSpectrumRssiRange_name = "GetSpectrumRssiRange";

                    private void _iceI_GetSpectrumRssiRange(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_rfChannelNumber, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult>(completed);
                        outAsync.invoke(
                            _GetSpectrumRssiRange_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_rfChannelNumber);
                            },
                            userException: (global::Ice.UserException ex) =>
                            {
                                try
                                {
                                    throw ex;
                                }
                                catch(OperationFailed)
                                {
                                    throw;
                                }
                                catch(global::Ice.UserException)
                                {
                                }
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult ret = new BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult();
                                ret.rssi = RssiArrayHelper.read(istr);
                                ret.startTimeInPicoseconds = istr.readLong();
                                ret.stopTimeInPicoseconds = istr.readLong();
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task<ChannelSummary[]> GetChannelsSummaryAsync(long fromTimeInPicoseconds, long toTimeInPicoseconds, 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_GetChannelsSummaryAsync(fromTimeInPicoseconds, toTimeInPicoseconds, context, progress, cancel, false);
                    }

                    private global::System.Threading.Tasks.Task<ChannelSummary[]> _iceI_GetChannelsSummaryAsync(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
                    {
                        iceCheckTwowayOnly(_GetChannelsSummary_name);
                        var completed = new global::IceInternal.OperationTaskCompletionCallback<ChannelSummary[]>(progress, cancel);
                        _iceI_GetChannelsSummary(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, context, synchronous, completed);
                        return completed.Task;
                    }

                    private const string _GetChannelsSummary_name = "GetChannelsSummary";

                    private void _iceI_GetChannelsSummary(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
                    {
                        var outAsync = getOutgoingAsync<ChannelSummary[]>(completed);
                        outAsync.invoke(
                            _GetChannelsSummary_name,
                            global::Ice.OperationMode.Normal,
                            global::Ice.FormatType.DefaultFormat,
                            context,
                            synchronous,
                            write: (global::Ice.OutputStream ostr) =>
                            {
                                ostr.writeLong(iceP_fromTimeInPicoseconds);
                                ostr.writeLong(iceP_toTimeInPicoseconds);
                            },
                            read: (global::Ice.InputStream istr) =>
                            {
                                ChannelSummary[] ret;
                                ret = ChannelsSummaryHelper.read(istr);
                                return ret;
                            });
                    }

                    public global::System.Threading.Tasks.Task ExportAudioAsync(string outputDirectory, 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_ExportAudioAsync(outputDirectory, context, progress, cancel, false);
                    }

                    private global::System.Threading.Tasks.Task _iceI_ExportAudioAsync(string iceP_outputDirectory, 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_ExportAudio(iceP_outputDirectory, context, synchronous, completed);
                        return completed.Task;
                    }

                    private const string _ExportAudio_name = "ExportAudio";

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

                    #endregion

                    #region Asynchronous operations

                    public global::Ice.AsyncResult<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 AppInfo end_GetAppInfo(global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetAppInfo_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<AppInfo>)resultI_.OutgoingAsync;
                        return outgoing_.getResult(resultI_.wait());
                    }

                    private global::Ice.AsyncResult<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<Callback_AnalyzerRemoteControl_GetAppInfo, AppInfo>(
                            (Callback_AnalyzerRemoteControl_GetAppInfo cb, AppInfo ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetAppInfo_name, cookie, completedCallback);
                        _iceI_GetAppInfo(context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<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<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<Callback_AnalyzerRemoteControl_ExitApp, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetAvailableDataSources, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SelectDataSource, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetSelectedDataSource, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_IsRecording, bool>(
                            (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<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 RecordingStatus end_GetRecordingStatus(global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetRecordingStatus_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<RecordingStatus>)resultI_.OutgoingAsync;
                        return outgoing_.getResult(resultI_.wait());
                    }

                    private global::Ice.AsyncResult<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<Callback_AnalyzerRemoteControl_GetRecordingStatus, RecordingStatus>(
                            (Callback_AnalyzerRemoteControl_GetRecordingStatus cb, RecordingStatus ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetRecordingStatus_name, cookie, completedCallback);
                        _iceI_GetRecordingStatus(context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<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<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<Callback_AnalyzerRemoteControl_StartRecording, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_StopRecordingAndSaveTraceFile, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_AbortRecordingAndDiscardTraceFile, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetRecordingOptions, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_ConfigureRecordingOptions, object>(
                            (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<Callback_AnalyzerRemoteControl_InsertMessage> begin_InsertMessage(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(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(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<Callback_AnalyzerRemoteControl_InsertMessage> begin_InsertMessage(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<Callback_AnalyzerRemoteControl_InsertMessage, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_IsLoading, bool>(
                            (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<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<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<Callback_AnalyzerRemoteControl_StartLoading, object>(
                            (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<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 TraceFileInfo end_GetTraceFileInfo(global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetTraceFileInfo_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<TraceFileInfo>)resultI_.OutgoingAsync;
                        return outgoing_.getResult(resultI_.wait());
                    }

                    private global::Ice.AsyncResult<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<Callback_AnalyzerRemoteControl_GetTraceFileInfo, TraceFileInfo>(
                            (Callback_AnalyzerRemoteControl_GetTraceFileInfo cb, TraceFileInfo ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetTraceFileInfo_name, cookie, completedCallback);
                        _iceI_GetTraceFileInfo(context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<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<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<Callback_AnalyzerRemoteControl_CloseTraceFile, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_IsModified, bool>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SaveChanges, object>(
                            (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<Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem> begin_AddMarkerOnSelectedOverviewItem(AddMarker marker, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_AddMarkerOnSelectedOverviewItem(marker, context, null, null, false);
                    }

                    public global::Ice.AsyncResult begin_AddMarkerOnSelectedOverviewItem(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(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<Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem> begin_AddMarkerOnSelectedOverviewItem(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<Callback_AnalyzerRemoteControl_AddMarkerOnSelectedOverviewItem, object>(
                            (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<Callback_AnalyzerRemoteControl_AddMarkerAtTime> begin_AddMarkerAtTime(long timeInPicoseconds, 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, 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, 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<Callback_AnalyzerRemoteControl_AddMarkerAtTime> begin_AddMarkerAtTime(long iceP_timeInPicoseconds, 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<Callback_AnalyzerRemoteControl_AddMarkerAtTime, object>(
                            (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<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 GetMarker[] end_GetMarkers(global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetMarkers_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<GetMarker[]>)resultI_.OutgoingAsync;
                        return outgoing_.getResult(resultI_.wait());
                    }

                    private global::Ice.AsyncResult<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<Callback_AnalyzerRemoteControl_GetMarkers, GetMarker[]>(
                            (Callback_AnalyzerRemoteControl_GetMarkers cb, GetMarker[] ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetMarkers_name, cookie, completedCallback);
                        _iceI_GetMarkers(context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_AnalyzerRemoteControl_Export> begin_Export(string outputFilename, string exportName, 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, 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, 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<Callback_AnalyzerRemoteControl_Export> begin_Export(string iceP_outputFilename, string iceP_exportName, 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<Callback_AnalyzerRemoteControl_Export, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetAvailableOverviews, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetSelectedOverview, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SelectOverview, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetAvailableProtocolLayers, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetSelectedProtocolLayer, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SelectProtocolLayer, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewQuery, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SetOverviewQuery, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_OverviewRootItem, int>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemDescription, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemsDescription, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemTimeInPicoseconds, long>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemsTimeInPicoseconds, long[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemData, byte[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemsData, byte[][]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemXmlReport, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReport, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemXmlReportFiltered, string>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemsXmlReportFiltered, string[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemChildCount, int>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemChild, int>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetOverviewItemChildren, int[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SearchOverviewItems, int[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_ReleaseAllOverviewItemHandles, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_SelectOverviewItem, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetSelectedOverviewItem, int>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetLogicSignalsState, int>(
                            (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<Callback_AnalyzerRemoteControl_FindLogicSignalsTransition> begin_FindLogicSignalsTransition(long fromTimeInPicoseconds, long toTimeInPicoseconds, int signalsMask, 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, 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, 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<AnalyzerRemoteControl_FindLogicSignalsTransitionResult>)resultI_.OutgoingAsync;
                        var result_ = outgoing_.getResult(resultI_.wait());
                        foundLogicSignalsState = result_.foundLogicSignalsState;
                        foundTimeInPicoseconds = result_.foundTimeInPicoseconds;
                    }

                    private global::Ice.AsyncResult<Callback_AnalyzerRemoteControl_FindLogicSignalsTransition> begin_FindLogicSignalsTransition(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_signalsMask, 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<Callback_AnalyzerRemoteControl_FindLogicSignalsTransition, AnalyzerRemoteControl_FindLogicSignalsTransitionResult>(
                            (Callback_AnalyzerRemoteControl_FindLogicSignalsTransition cb, 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<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 RunningTask[] end_GetRunningTasks(global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetRunningTasks_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<RunningTask[]>)resultI_.OutgoingAsync;
                        return outgoing_.getResult(resultI_.wait());
                    }

                    private global::Ice.AsyncResult<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<Callback_AnalyzerRemoteControl_GetRunningTasks, RunningTask[]>(
                            (Callback_AnalyzerRemoteControl_GetRunningTasks cb, RunningTask[] ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetRunningTasks_name, cookie, completedCallback);
                        _iceI_GetRunningTasks(context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<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<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<Callback_AnalyzerRemoteControl_AbortRunningTask, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_GetSettings, byte[]>(
                            (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<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<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<Callback_AnalyzerRemoteControl_ConfigureSettings, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_CancelUserInteraction, object>(
                            (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<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<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<Callback_AnalyzerRemoteControl_InsertComment, object>(
                            (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_BluetoothAnalyzerRemoteControl_SplitTraceFileAndContinueRecording> begin_SplitTraceFileAndContinueRecording(string filename, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_SplitTraceFileAndContinueRecording(filename, context, null, null, false);
                    }

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

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

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

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

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_AddLinkKey> begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_AddLinkKey(bdaddr1, bdaddr2, linkKey, context, null, null, false);
                    }

                    public global::Ice.AsyncResult begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_AddLinkKey(bdaddr1, bdaddr2, linkKey, new global::Ice.OptionalContext(), callback, cookie, false);
                    }

                    public global::Ice.AsyncResult begin_AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_AddLinkKey(bdaddr1, bdaddr2, linkKey, context, callback, cookie, false);
                    }

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

                    private global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_AddLinkKey> begin_AddLinkKey(long iceP_bdaddr1, long iceP_bdaddr2, byte[] iceP_linkKey, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                    {
                        iceCheckAsyncTwowayOnly(_AddLinkKey_name);
                        var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_BluetoothAnalyzerRemoteControl_AddLinkKey, object>(
                            (Callback_BluetoothAnalyzerRemoteControl_AddLinkKey cb, object ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke();
                                }
                            },
                            this, _AddLinkKey_name, cookie, completedCallback);
                        _iceI_AddLinkKey(iceP_bdaddr1, iceP_bdaddr2, iceP_linkKey, context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_ConfigureDeviceFilter> begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_ConfigureDeviceFilter(mode, deviceAddrs, context, null, null, false);
                    }

                    public global::Ice.AsyncResult begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_ConfigureDeviceFilter(mode, deviceAddrs, new global::Ice.OptionalContext(), callback, cookie, false);
                    }

                    public global::Ice.AsyncResult begin_ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_ConfigureDeviceFilter(mode, deviceAddrs, context, callback, cookie, false);
                    }

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

                    private global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_ConfigureDeviceFilter> begin_ConfigureDeviceFilter(DeviceFilterMode iceP_mode, long[] iceP_deviceAddrs, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                    {
                        iceCheckAsyncTwowayOnly(_ConfigureDeviceFilter_name);
                        var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_BluetoothAnalyzerRemoteControl_ConfigureDeviceFilter, object>(
                            (Callback_BluetoothAnalyzerRemoteControl_ConfigureDeviceFilter cb, object ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke();
                                }
                            },
                            this, _ConfigureDeviceFilter_name, cookie, completedCallback);
                        _iceI_ConfigureDeviceFilter(iceP_mode, iceP_deviceAddrs, context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssi> begin_GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_GetSpectrumRssi(timeInPicoseconds, rfChannelNumber, context, null, null, false);
                    }

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

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

                    public void end_GetSpectrumRssi(out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSpectrumRssi_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult>)resultI_.OutgoingAsync;
                        var result_ = outgoing_.getResult(resultI_.wait());
                        rssi = result_.rssi;
                        startTimeInPicoseconds = result_.startTimeInPicoseconds;
                        stopTimeInPicoseconds = result_.stopTimeInPicoseconds;
                    }

                    private global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssi> begin_GetSpectrumRssi(long iceP_timeInPicoseconds, int iceP_rfChannelNumber, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                    {
                        iceCheckAsyncTwowayOnly(_GetSpectrumRssi_name);
                        var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssi, BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult>(
                            (Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssi cb, BluetoothAnalyzerRemoteControl_GetSpectrumRssiResult ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret.rssi, ret.startTimeInPicoseconds, ret.stopTimeInPicoseconds);
                                }
                            },
                            this, _GetSpectrumRssi_name, cookie, completedCallback);
                        _iceI_GetSpectrumRssi(iceP_timeInPicoseconds, iceP_rfChannelNumber, context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange> begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_GetSpectrumRssiRange(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, context, null, null, false);
                    }

                    public global::Ice.AsyncResult begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_GetSpectrumRssiRange(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, new global::Ice.OptionalContext(), callback, cookie, false);
                    }

                    public global::Ice.AsyncResult begin_GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
                    {
                        return begin_GetSpectrumRssiRange(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, context, callback, cookie, false);
                    }

                    public void end_GetSpectrumRssiRange(out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.AsyncResult asyncResult)
                    {
                        var resultI_ = global::IceInternal.AsyncResultI.check(asyncResult, this, _GetSpectrumRssiRange_name);
                        var outgoing_ = (global::IceInternal.OutgoingAsyncT<BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult>)resultI_.OutgoingAsync;
                        var result_ = outgoing_.getResult(resultI_.wait());
                        rssi = result_.rssi;
                        startTimeInPicoseconds = result_.startTimeInPicoseconds;
                        stopTimeInPicoseconds = result_.stopTimeInPicoseconds;
                    }

                    private global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange> begin_GetSpectrumRssiRange(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, int iceP_rfChannelNumber, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                    {
                        iceCheckAsyncTwowayOnly(_GetSpectrumRssiRange_name);
                        var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange, BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult>(
                            (Callback_BluetoothAnalyzerRemoteControl_GetSpectrumRssiRange cb, BluetoothAnalyzerRemoteControl_GetSpectrumRssiRangeResult ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret.rssi, ret.startTimeInPicoseconds, ret.stopTimeInPicoseconds);
                                }
                            },
                            this, _GetSpectrumRssiRange_name, cookie, completedCallback);
                        _iceI_GetSpectrumRssiRange(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, iceP_rfChannelNumber, context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetChannelsSummary> begin_GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_GetChannelsSummary(fromTimeInPicoseconds, toTimeInPicoseconds, context, null, null, false);
                    }

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

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

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

                    private global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_GetChannelsSummary> begin_GetChannelsSummary(long iceP_fromTimeInPicoseconds, long iceP_toTimeInPicoseconds, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
                    {
                        iceCheckAsyncTwowayOnly(_GetChannelsSummary_name);
                        var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_BluetoothAnalyzerRemoteControl_GetChannelsSummary, ChannelSummary[]>(
                            (Callback_BluetoothAnalyzerRemoteControl_GetChannelsSummary cb, ChannelSummary[] ret) =>
                            {
                                if(cb != null)
                                {
                                    cb.Invoke(ret);
                                }
                            },
                            this, _GetChannelsSummary_name, cookie, completedCallback);
                        _iceI_GetChannelsSummary(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, context, synchronous, completed);
                        return completed;
                    }

                    public global::Ice.AsyncResult<Callback_BluetoothAnalyzerRemoteControl_ExportAudio> begin_ExportAudio(string outputDirectory, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
                    {
                        return begin_ExportAudio(outputDirectory, context, null, null, false);
                    }

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

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

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

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

                    #endregion

                    #region Checked and unchecked cast operations

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

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

                    public static BluetoothAnalyzerRemoteControlPrx 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()))
                            {
                                BluetoothAnalyzerRemoteControlPrxHelper h = new BluetoothAnalyzerRemoteControlPrxHelper();
                                h.iceCopyFrom(bb);
                                return h;
                            }
                        }
                        catch(global::Ice.FacetNotExistException)
                        {
                        }
                        return null;
                    }

                    public static BluetoothAnalyzerRemoteControlPrx 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))
                            {
                                BluetoothAnalyzerRemoteControlPrxHelper h = new BluetoothAnalyzerRemoteControlPrxHelper();
                                h.iceCopyFrom(bb);
                                return h;
                            }
                        }
                        catch(global::Ice.FacetNotExistException)
                        {
                        }
                        return null;
                    }

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

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

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

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

                    #endregion

                    #region Marshaling support

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

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

                    #endregion
                }
            }
        }
    }
}

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

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

                    public abstract void AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.Current current = null);

                    public abstract void ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.Current current = null);

                    public abstract void GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null);

                    public abstract void GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null);

                    public abstract ChannelSummary[] GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.Current current = null);

                    public abstract void ExportAudio(string outputDirectory, 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, AddMarker marker, global::Ice.Current current = null);

                    public abstract void AddMarkerOnSelectedOverviewItem(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, ExportOption[] exportOptions, global::Ice.Current current = null);

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

                    public abstract 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 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 RecordingStatus GetRecordingStatus(global::Ice.Current current = null);

                    public abstract 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 TraceFileInfo GetTraceFileInfo(global::Ice.Current current = null);

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

                    public abstract void InsertMessage(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::BluetoothAnalyzerRemoteControl",
                        "::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_SplitTraceFileAndContinueRecording(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        string iceP_filename;
                        iceP_filename = istr.readString();
                        inS.endReadParams();
                        obj.SplitTraceFileAndContinueRecording(iceP_filename, 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_AddLinkKey(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        long iceP_bdaddr1;
                        long iceP_bdaddr2;
                        byte[] iceP_linkKey;
                        iceP_bdaddr1 = istr.readLong();
                        iceP_bdaddr2 = istr.readLong();
                        iceP_linkKey = LinkKeyByteArrayHelper.read(istr);
                        inS.endReadParams();
                        obj.AddLinkKey(iceP_bdaddr1, iceP_bdaddr2, iceP_linkKey, 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_ConfigureDeviceFilter(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        DeviceFilterMode iceP_mode;
                        long[] iceP_deviceAddrs;
                        iceP_mode = (DeviceFilterMode)istr.readEnum(3);
                        iceP_deviceAddrs = DeviceAddressArrayHelper.read(istr);
                        inS.endReadParams();
                        obj.ConfigureDeviceFilter(iceP_mode, iceP_deviceAddrs, 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_GetSpectrumRssi(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        long iceP_timeInPicoseconds;
                        int iceP_rfChannelNumber;
                        iceP_timeInPicoseconds = istr.readLong();
                        iceP_rfChannelNumber = istr.readInt();
                        inS.endReadParams();
                        double iceP_rssi;
                        long iceP_startTimeInPicoseconds;
                        long iceP_stopTimeInPicoseconds;
                        obj.GetSpectrumRssi(iceP_timeInPicoseconds, iceP_rfChannelNumber, out iceP_rssi, out iceP_startTimeInPicoseconds, out iceP_stopTimeInPicoseconds, current);
                        var ostr = inS.startWriteParams();
                        ostr.writeDouble(iceP_rssi);
                        ostr.writeLong(iceP_startTimeInPicoseconds);
                        ostr.writeLong(iceP_stopTimeInPicoseconds);
                        inS.endWriteParams(ostr);
                        return inS.setResult(ostr);
                    }

                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                    public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                    iceD_GetSpectrumRssiRange(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        long iceP_fromTimeInPicoseconds;
                        long iceP_toTimeInPicoseconds;
                        int iceP_rfChannelNumber;
                        iceP_fromTimeInPicoseconds = istr.readLong();
                        iceP_toTimeInPicoseconds = istr.readLong();
                        iceP_rfChannelNumber = istr.readInt();
                        inS.endReadParams();
                        double[] iceP_rssi;
                        long iceP_startTimeInPicoseconds;
                        long iceP_stopTimeInPicoseconds;
                        obj.GetSpectrumRssiRange(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, iceP_rfChannelNumber, out iceP_rssi, out iceP_startTimeInPicoseconds, out iceP_stopTimeInPicoseconds, current);
                        var ostr = inS.startWriteParams();
                        RssiArrayHelper.write(ostr, iceP_rssi);
                        ostr.writeLong(iceP_startTimeInPicoseconds);
                        ostr.writeLong(iceP_stopTimeInPicoseconds);
                        inS.endWriteParams(ostr);
                        return inS.setResult(ostr);
                    }

                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                    public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                    iceD_GetChannelsSummary(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        long iceP_fromTimeInPicoseconds;
                        long iceP_toTimeInPicoseconds;
                        iceP_fromTimeInPicoseconds = istr.readLong();
                        iceP_toTimeInPicoseconds = istr.readLong();
                        inS.endReadParams();
                        var ret = obj.GetChannelsSummary(iceP_fromTimeInPicoseconds, iceP_toTimeInPicoseconds, current);
                        var ostr = inS.startWriteParams();
                        ChannelsSummaryHelper.write(ostr, ret);
                        inS.endWriteParams(ostr);
                        return inS.setResult(ostr);
                    }

                    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
                    public static global::System.Threading.Tasks.Task<global::Ice.OutputStream>
                    iceD_ExportAudio(BluetoothAnalyzerRemoteControl obj, global::IceInternal.Incoming inS, global::Ice.Current current)
                    {
                        global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
                        var istr = inS.startReadParams();
                        string iceP_outputDirectory;
                        iceP_outputDirectory = istr.readString();
                        inS.endReadParams();
                        obj.ExportAudio(iceP_outputDirectory, current);
                        return inS.setResult(inS.writeEmptyParams());
                    }

                    private static readonly string[] _all =
                    {
                        "AbortRecordingAndDiscardTraceFile",
                        "AbortRunningTask",
                        "AddLinkKey",
                        "AddMarkerAtTime",
                        "AddMarkerOnSelectedOverviewItem",
                        "CancelUserInteraction",
                        "CloseTraceFile",
                        "ConfigureDeviceFilter",
                        "ConfigureRecordingOptions",
                        "ConfigureSettings",
                        "ExitApp",
                        "Export",
                        "ExportAudio",
                        "FindLogicSignalsTransition",
                        "GetAppInfo",
                        "GetAvailableDataSources",
                        "GetAvailableOverviews",
                        "GetAvailableProtocolLayers",
                        "GetChannelsSummary",
                        "GetLogicSignalsState",
                        "GetMarkers",
                        "GetOverviewItemChild",
                        "GetOverviewItemChildCount",
                        "GetOverviewItemChildren",
                        "GetOverviewItemData",
                        "GetOverviewItemDescription",
                        "GetOverviewItemTimeInPicoseconds",
                        "GetOverviewItemXmlReport",
                        "GetOverviewItemXmlReportFiltered",
                        "GetOverviewItemsData",
                        "GetOverviewItemsDescription",
                        "GetOverviewItemsTimeInPicoseconds",
                        "GetOverviewItemsXmlReport",
                        "GetOverviewItemsXmlReportFiltered",
                        "GetOverviewQuery",
                        "GetRecordingOptions",
                        "GetRecordingStatus",
                        "GetRunningTasks",
                        "GetSelectedDataSource",
                        "GetSelectedOverview",
                        "GetSelectedOverviewItem",
                        "GetSelectedProtocolLayer",
                        "GetSettings",
                        "GetSpectrumRssi",
                        "GetSpectrumRssiRange",
                        "GetTraceFileInfo",
                        "InsertComment",
                        "InsertMessage",
                        "IsLoading",
                        "IsModified",
                        "IsRecording",
                        "OverviewRootItem",
                        "ReleaseAllOverviewItemHandles",
                        "SaveChanges",
                        "SearchOverviewItems",
                        "SelectDataSource",
                        "SelectOverview",
                        "SelectOverviewItem",
                        "SelectProtocolLayer",
                        "SetOverviewQuery",
                        "SplitTraceFileAndContinueRecording",
                        "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 AnalyzerRemoteControlDisp_.iceD_AbortRecordingAndDiscardTraceFile(this, inS, current);
                            }
                            case 1:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_AbortRunningTask(this, inS, current);
                            }
                            case 2:
                            {
                                return iceD_AddLinkKey(this, inS, current);
                            }
                            case 3:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_AddMarkerAtTime(this, inS, current);
                            }
                            case 4:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_AddMarkerOnSelectedOverviewItem(this, inS, current);
                            }
                            case 5:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_CancelUserInteraction(this, inS, current);
                            }
                            case 6:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_CloseTraceFile(this, inS, current);
                            }
                            case 7:
                            {
                                return iceD_ConfigureDeviceFilter(this, inS, current);
                            }
                            case 8:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_ConfigureRecordingOptions(this, inS, current);
                            }
                            case 9:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_ConfigureSettings(this, inS, current);
                            }
                            case 10:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_ExitApp(this, inS, current);
                            }
                            case 11:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_Export(this, inS, current);
                            }
                            case 12:
                            {
                                return iceD_ExportAudio(this, inS, current);
                            }
                            case 13:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_FindLogicSignalsTransition(this, inS, current);
                            }
                            case 14:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetAppInfo(this, inS, current);
                            }
                            case 15:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetAvailableDataSources(this, inS, current);
                            }
                            case 16:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetAvailableOverviews(this, inS, current);
                            }
                            case 17:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetAvailableProtocolLayers(this, inS, current);
                            }
                            case 18:
                            {
                                return iceD_GetChannelsSummary(this, inS, current);
                            }
                            case 19:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetLogicSignalsState(this, inS, current);
                            }
                            case 20:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetMarkers(this, inS, current);
                            }
                            case 21:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChild(this, inS, current);
                            }
                            case 22:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChildCount(this, inS, current);
                            }
                            case 23:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemChildren(this, inS, current);
                            }
                            case 24:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemData(this, inS, current);
                            }
                            case 25:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemDescription(this, inS, current);
                            }
                            case 26:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemTimeInPicoseconds(this, inS, current);
                            }
                            case 27:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemXmlReport(this, inS, current);
                            }
                            case 28:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemXmlReportFiltered(this, inS, current);
                            }
                            case 29:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsData(this, inS, current);
                            }
                            case 30:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsDescription(this, inS, current);
                            }
                            case 31:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsTimeInPicoseconds(this, inS, current);
                            }
                            case 32:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsXmlReport(this, inS, current);
                            }
                            case 33:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewItemsXmlReportFiltered(this, inS, current);
                            }
                            case 34:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetOverviewQuery(this, inS, current);
                            }
                            case 35:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetRecordingOptions(this, inS, current);
                            }
                            case 36:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetRecordingStatus(this, inS, current);
                            }
                            case 37:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetRunningTasks(this, inS, current);
                            }
                            case 38:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetSelectedDataSource(this, inS, current);
                            }
                            case 39:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetSelectedOverview(this, inS, current);
                            }
                            case 40:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetSelectedOverviewItem(this, inS, current);
                            }
                            case 41:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetSelectedProtocolLayer(this, inS, current);
                            }
                            case 42:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetSettings(this, inS, current);
                            }
                            case 43:
                            {
                                return iceD_GetSpectrumRssi(this, inS, current);
                            }
                            case 44:
                            {
                                return iceD_GetSpectrumRssiRange(this, inS, current);
                            }
                            case 45:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_GetTraceFileInfo(this, inS, current);
                            }
                            case 46:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_InsertComment(this, inS, current);
                            }
                            case 47:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_InsertMessage(this, inS, current);
                            }
                            case 48:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_IsLoading(this, inS, current);
                            }
                            case 49:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_IsModified(this, inS, current);
                            }
                            case 50:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_IsRecording(this, inS, current);
                            }
                            case 51:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_OverviewRootItem(this, inS, current);
                            }
                            case 52:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_ReleaseAllOverviewItemHandles(this, inS, current);
                            }
                            case 53:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SaveChanges(this, inS, current);
                            }
                            case 54:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SearchOverviewItems(this, inS, current);
                            }
                            case 55:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SelectDataSource(this, inS, current);
                            }
                            case 56:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SelectOverview(this, inS, current);
                            }
                            case 57:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SelectOverviewItem(this, inS, current);
                            }
                            case 58:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SelectProtocolLayer(this, inS, current);
                            }
                            case 59:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_SetOverviewQuery(this, inS, current);
                            }
                            case 60:
                            {
                                return iceD_SplitTraceFileAndContinueRecording(this, inS, current);
                            }
                            case 61:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_StartLoading(this, inS, current);
                            }
                            case 62:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_StartRecording(this, inS, current);
                            }
                            case 63:
                            {
                                return AnalyzerRemoteControlDisp_.iceD_StopRecordingAndSaveTraceFile(this, inS, current);
                            }
                            case 64:
                            {
                                return global::Ice.ObjectImpl.iceD_ice_id(this, inS, current);
                            }
                            case 65:
                            {
                                return global::Ice.ObjectImpl.iceD_ice_ids(this, inS, current);
                            }
                            case 66:
                            {
                                return global::Ice.ObjectImpl.iceD_ice_isA(this, inS, current);
                            }
                            case 67:
                            {
                                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 BluetoothAnalyzerRemoteControlTie_ : BluetoothAnalyzerRemoteControlDisp_, global::Ice.TieBase
                {
                    public BluetoothAnalyzerRemoteControlTie_()
                    {
                    }

                    public BluetoothAnalyzerRemoteControlTie_(BluetoothAnalyzerRemoteControlOperations_ del)
                    {
                        _ice_delegate = del;
                    }

                    public object ice_delegate()
                    {
                        return _ice_delegate;
                    }

                    public void ice_delegate(object del)
                    {
                        _ice_delegate = (BluetoothAnalyzerRemoteControlOperations_)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 BluetoothAnalyzerRemoteControlTie_))
                        {
                            return false;
                        }
                        if(_ice_delegate == null)
                        {
                            return ((BluetoothAnalyzerRemoteControlTie_)rhs)._ice_delegate == null;
                        }
                        return _ice_delegate.Equals(((BluetoothAnalyzerRemoteControlTie_)rhs)._ice_delegate);
                    }

                    public override void SplitTraceFileAndContinueRecording(string filename, global::Ice.Current current = null)
                    {
                        _ice_delegate.SplitTraceFileAndContinueRecording(filename, current);
                    }

                    public override void AddLinkKey(long bdaddr1, long bdaddr2, byte[] linkKey, global::Ice.Current current = null)
                    {
                        _ice_delegate.AddLinkKey(bdaddr1, bdaddr2, linkKey, current);
                    }

                    public override void ConfigureDeviceFilter(DeviceFilterMode mode, long[] deviceAddrs, global::Ice.Current current = null)
                    {
                        _ice_delegate.ConfigureDeviceFilter(mode, deviceAddrs, current);
                    }

                    public override void GetSpectrumRssi(long timeInPicoseconds, int rfChannelNumber, out double rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null)
                    {
                        _ice_delegate.GetSpectrumRssi(timeInPicoseconds, rfChannelNumber, out rssi, out startTimeInPicoseconds, out stopTimeInPicoseconds, current);
                    }

                    public override void GetSpectrumRssiRange(long fromTimeInPicoseconds, long toTimeInPicoseconds, int rfChannelNumber, out double[] rssi, out long startTimeInPicoseconds, out long stopTimeInPicoseconds, global::Ice.Current current = null)
                    {
                        _ice_delegate.GetSpectrumRssiRange(fromTimeInPicoseconds, toTimeInPicoseconds, rfChannelNumber, out rssi, out startTimeInPicoseconds, out stopTimeInPicoseconds, current);
                    }

                    public override ChannelSummary[] GetChannelsSummary(long fromTimeInPicoseconds, long toTimeInPicoseconds, global::Ice.Current current = null)
                    {
                        return _ice_delegate.GetChannelsSummary(fromTimeInPicoseconds, toTimeInPicoseconds, current);
                    }

                    public override void ExportAudio(string outputDirectory, global::Ice.Current current = null)
                    {
                        _ice_delegate.ExportAudio(outputDirectory, 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 BluetoothAnalyzerRemoteControlOperations_ _ice_delegate;
                }
            }
        }
    }
}
