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


using _System = global::System;

#pragma warning disable 1591

namespace LizardProtocol
{
    [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 Address
    {
        #region Slice data members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short segment;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int offset;

        #endregion

        partial void ice_initialize();

        #region Constructor

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Address(short segment, int offset)
        {
            this.segment = segment;
            this.offset = offset;
            ice_initialize();
        }

        #endregion

        #region Object members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override int GetHashCode()
        {
            int h_ = 5381;
            global::IceInternal.HashUtil.hashAdd(ref h_, "::LizardProtocol::Address");
            global::IceInternal.HashUtil.hashAdd(ref h_, segment);
            global::IceInternal.HashUtil.hashAdd(ref h_, offset);
            return h_;
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override bool Equals(object other)
        {
            if(!(other is Address))
            {
                return false;
            }
            Address o = (Address)other;
            if(!this.segment.Equals(o.segment))
            {
                return false;
            }
            if(!this.offset.Equals(o.offset))
            {
                return false;
            }
            return true;
        }

        #endregion

        #region Comparison members

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

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

        #endregion

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_writeMembers(global::Ice.OutputStream ostr)
        {
            ostr.writeShort(this.segment);
            ostr.writeInt(this.offset);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_readMembers(global::Ice.InputStream istr)
        {
            this.segment = istr.readShort();
            this.offset = istr.readInt();
        }

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

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

        #endregion
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public enum Register
    {
        Flags,
        EAX,
        EBX,
        ECX,
        EDX,
        ESI,
        EDI,
        EBP,
        ESP,
        EIP,
        ES,
        CS,
        SS,
        DS,
        FS,
        GS
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public sealed class RegisterHelper
    {
        public static void write(global::Ice.OutputStream ostr, Register v)
        {
            ostr.writeEnum((int)v, 15);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static Register read(global::Ice.InputStream istr)
        {
            Register v;
            v = (Register)istr.readEnum(15);
            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 Registers
    {
        #region Slice data members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public bool stopped;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int flags;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int eax;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int ebx;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int ecx;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int edx;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int esi;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int edi;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int ebp;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int esp;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int eip;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short es;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short cs;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short ss;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short ds;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short fs;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short gs;

        #endregion

        partial void ice_initialize();

        #region Constructor

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Registers(bool stopped, int flags, int eax, int ebx, int ecx, int edx, int esi, int edi, int ebp, int esp, int eip, short es, short cs, short ss, short ds, short fs, short gs)
        {
            this.stopped = stopped;
            this.flags = flags;
            this.eax = eax;
            this.ebx = ebx;
            this.ecx = ecx;
            this.edx = edx;
            this.esi = esi;
            this.edi = edi;
            this.ebp = ebp;
            this.esp = esp;
            this.eip = eip;
            this.es = es;
            this.cs = cs;
            this.ss = ss;
            this.ds = ds;
            this.fs = fs;
            this.gs = gs;
            ice_initialize();
        }

        #endregion

        #region Object members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override int GetHashCode()
        {
            int h_ = 5381;
            global::IceInternal.HashUtil.hashAdd(ref h_, "::LizardProtocol::Registers");
            global::IceInternal.HashUtil.hashAdd(ref h_, stopped);
            global::IceInternal.HashUtil.hashAdd(ref h_, flags);
            global::IceInternal.HashUtil.hashAdd(ref h_, eax);
            global::IceInternal.HashUtil.hashAdd(ref h_, ebx);
            global::IceInternal.HashUtil.hashAdd(ref h_, ecx);
            global::IceInternal.HashUtil.hashAdd(ref h_, edx);
            global::IceInternal.HashUtil.hashAdd(ref h_, esi);
            global::IceInternal.HashUtil.hashAdd(ref h_, edi);
            global::IceInternal.HashUtil.hashAdd(ref h_, ebp);
            global::IceInternal.HashUtil.hashAdd(ref h_, esp);
            global::IceInternal.HashUtil.hashAdd(ref h_, eip);
            global::IceInternal.HashUtil.hashAdd(ref h_, es);
            global::IceInternal.HashUtil.hashAdd(ref h_, cs);
            global::IceInternal.HashUtil.hashAdd(ref h_, ss);
            global::IceInternal.HashUtil.hashAdd(ref h_, ds);
            global::IceInternal.HashUtil.hashAdd(ref h_, fs);
            global::IceInternal.HashUtil.hashAdd(ref h_, gs);
            return h_;
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override bool Equals(object other)
        {
            if(!(other is Registers))
            {
                return false;
            }
            Registers o = (Registers)other;
            if(!this.stopped.Equals(o.stopped))
            {
                return false;
            }
            if(!this.flags.Equals(o.flags))
            {
                return false;
            }
            if(!this.eax.Equals(o.eax))
            {
                return false;
            }
            if(!this.ebx.Equals(o.ebx))
            {
                return false;
            }
            if(!this.ecx.Equals(o.ecx))
            {
                return false;
            }
            if(!this.edx.Equals(o.edx))
            {
                return false;
            }
            if(!this.esi.Equals(o.esi))
            {
                return false;
            }
            if(!this.edi.Equals(o.edi))
            {
                return false;
            }
            if(!this.ebp.Equals(o.ebp))
            {
                return false;
            }
            if(!this.esp.Equals(o.esp))
            {
                return false;
            }
            if(!this.eip.Equals(o.eip))
            {
                return false;
            }
            if(!this.es.Equals(o.es))
            {
                return false;
            }
            if(!this.cs.Equals(o.cs))
            {
                return false;
            }
            if(!this.ss.Equals(o.ss))
            {
                return false;
            }
            if(!this.ds.Equals(o.ds))
            {
                return false;
            }
            if(!this.fs.Equals(o.fs))
            {
                return false;
            }
            if(!this.gs.Equals(o.gs))
            {
                return false;
            }
            return true;
        }

        #endregion

        #region Comparison members

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

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

        #endregion

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_writeMembers(global::Ice.OutputStream ostr)
        {
            ostr.writeBool(this.stopped);
            ostr.writeInt(this.flags);
            ostr.writeInt(this.eax);
            ostr.writeInt(this.ebx);
            ostr.writeInt(this.ecx);
            ostr.writeInt(this.edx);
            ostr.writeInt(this.esi);
            ostr.writeInt(this.edi);
            ostr.writeInt(this.ebp);
            ostr.writeInt(this.esp);
            ostr.writeInt(this.eip);
            ostr.writeShort(this.es);
            ostr.writeShort(this.cs);
            ostr.writeShort(this.ss);
            ostr.writeShort(this.ds);
            ostr.writeShort(this.fs);
            ostr.writeShort(this.gs);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_readMembers(global::Ice.InputStream istr)
        {
            this.stopped = istr.readBool();
            this.flags = istr.readInt();
            this.eax = istr.readInt();
            this.ebx = istr.readInt();
            this.ecx = istr.readInt();
            this.edx = istr.readInt();
            this.esi = istr.readInt();
            this.edi = istr.readInt();
            this.ebp = istr.readInt();
            this.esp = istr.readInt();
            this.eip = istr.readInt();
            this.es = istr.readShort();
            this.cs = istr.readShort();
            this.ss = istr.readShort();
            this.ds = istr.readShort();
            this.fs = istr.readShort();
            this.gs = istr.readShort();
        }

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

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

        #endregion
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public enum BreakpointType
    {
        Unknown,
        Normal,
        Ephemeral,
        Read,
        Write,
        Interrupt,
        InterruptWithAH,
        InterruptWithAX
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public sealed class BreakpointTypeHelper
    {
        public static void write(global::Ice.OutputStream ostr, BreakpointType v)
        {
            ostr.writeEnum((int)v, 7);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static BreakpointType read(global::Ice.InputStream istr)
        {
            BreakpointType v;
            v = (BreakpointType)istr.readEnum(7);
            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 Breakpoint
    {
        #region Slice data members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int id;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Address address;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public BreakpointType type;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public bool enabled;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public byte ah;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public byte al;

        #endregion

        partial void ice_initialize();

        #region Constructor

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Breakpoint(int id, Address address, BreakpointType type, bool enabled, byte ah, byte al)
        {
            this.id = id;
            this.address = address;
            this.type = type;
            this.enabled = enabled;
            this.ah = ah;
            this.al = al;
            ice_initialize();
        }

        #endregion

        #region Object members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override int GetHashCode()
        {
            int h_ = 5381;
            global::IceInternal.HashUtil.hashAdd(ref h_, "::LizardProtocol::Breakpoint");
            global::IceInternal.HashUtil.hashAdd(ref h_, id);
            global::IceInternal.HashUtil.hashAdd(ref h_, address);
            global::IceInternal.HashUtil.hashAdd(ref h_, type);
            global::IceInternal.HashUtil.hashAdd(ref h_, enabled);
            global::IceInternal.HashUtil.hashAdd(ref h_, ah);
            global::IceInternal.HashUtil.hashAdd(ref h_, al);
            return h_;
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override bool Equals(object other)
        {
            if(!(other is Breakpoint))
            {
                return false;
            }
            Breakpoint o = (Breakpoint)other;
            if(!this.id.Equals(o.id))
            {
                return false;
            }
            if(!this.address.Equals(o.address))
            {
                return false;
            }
            if(!this.type.Equals(o.type))
            {
                return false;
            }
            if(!this.enabled.Equals(o.enabled))
            {
                return false;
            }
            if(!this.ah.Equals(o.ah))
            {
                return false;
            }
            if(!this.al.Equals(o.al))
            {
                return false;
            }
            return true;
        }

        #endregion

        #region Comparison members

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

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

        #endregion

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_writeMembers(global::Ice.OutputStream ostr)
        {
            ostr.writeInt(this.id);
            this.address.ice_writeMembers(ostr);
            ostr.writeEnum((int)this.type, 7);
            ostr.writeBool(this.enabled);
            ostr.writeByte(this.ah);
            ostr.writeByte(this.al);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_readMembers(global::Ice.InputStream istr)
        {
            this.id = istr.readInt();
            this.address.ice_readMembers(istr);
            this.type = (BreakpointType)istr.readEnum(7);
            this.enabled = istr.readBool();
            this.ah = istr.readByte();
            this.al = istr.readByte();
        }

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

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

        #endregion
    }

    [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 class AssemblyLine : global::System.ICloneable
    {
        #region Slice data members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Address address;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public string line;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public byte[] bytes;

        #endregion

        partial void ice_initialize();

        #region Constructors

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public AssemblyLine()
        {
            this.address = new Address();
            this.line = "";
            ice_initialize();
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public AssemblyLine(Address address, string line, byte[] bytes)
        {
            this.address = address;
            this.line = line;
            this.bytes = bytes;
            ice_initialize();
        }

        #endregion

        #region ICloneable members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public object Clone()
        {
            return MemberwiseClone();
        }

        #endregion

        #region Object members

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override int GetHashCode()
        {
            int h_ = 5381;
            global::IceInternal.HashUtil.hashAdd(ref h_, "::LizardProtocol::AssemblyLine");
            global::IceInternal.HashUtil.hashAdd(ref h_, address);
            global::IceInternal.HashUtil.hashAdd(ref h_, line);
            global::IceInternal.HashUtil.hashAdd(ref h_, bytes);
            return h_;
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override bool Equals(object other)
        {
            if(object.ReferenceEquals(this, other))
            {
                return true;
            }
            if(other == null)
            {
                return false;
            }
            if(GetType() != other.GetType())
            {
                return false;
            }
            AssemblyLine o = (AssemblyLine)other;
            if(!this.address.Equals(o.address))
            {
                return false;
            }
            if(this.line == null)
            {
                if(o.line != null)
                {
                    return false;
                }
            }
            else
            {
                if(!this.line.Equals(o.line))
                {
                    return false;
                }
            }
            if(this.bytes == null)
            {
                if(o.bytes != null)
                {
                    return false;
                }
            }
            else
            {
                if(!IceUtilInternal.Arrays.Equals(this.bytes, o.bytes))
                {
                    return false;
                }
            }
            return true;
        }

        #endregion

        #region Comparison members

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

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

        #endregion

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_writeMembers(global::Ice.OutputStream ostr)
        {
            this.address.ice_writeMembers(ostr);
            ostr.writeString(this.line);
            ByteSequenceHelper.write(ostr, this.bytes);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public void ice_readMembers(global::Ice.InputStream istr)
        {
            this.address.ice_readMembers(istr);
            this.line = istr.readString();
            this.bytes = ByteSequenceHelper.read(istr);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static void ice_write(global::Ice.OutputStream ostr, AssemblyLine v)
        {
            if(v == null)
            {
                _nullMarshalValue.ice_writeMembers(ostr);
            }
            else
            {
                v.ice_writeMembers(ostr);
            }
        }

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

        private static readonly AssemblyLine _nullMarshalValue = new AssemblyLine();

        #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 DebugClient : global::Ice.Object, DebugClientOperations_
    {
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public enum SegmentType
    {
        SysInvalid = 0,
        Sys286TssA = 1,
        SysLdt = 2,
        Sys286TssB = 3,
        Sys286CallGate = 4,
        SysTaskGate = 5,
        Sys286IntGate = 6,
        Sys286TrapGate = 7,
        Sys386TssA = 9,
        Sys386TssB = 11,
        Sys386CallGate = 12,
        Sys386IntGate = 14,
        Sys386TrapGate = 15,
        DataUpRead = 16,
        DataUpReadAcc = 17,
        DataUpWrite = 18,
        DataUpWriteAcc = 19,
        DataDnRead = 20,
        DataDnReadAcc = 21,
        DataDnWrite = 22,
        DataDnWriteAcc = 23,
        CodeAcc = 24,
        Code = 25,
        CodeReadAcc = 26,
        CodeRead = 27,
        CodeConfAcc = 28,
        CodeConf = 29,
        CodeReadConfAcc = 30,
        CodeReadConf = 31
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public sealed class SegmentTypeHelper
    {
        public static void write(global::Ice.OutputStream ostr, SegmentType v)
        {
            ostr.writeEnum((int)v, 31);
        }

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

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

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public SegmentType type;

        #endregion

        partial void ice_initialize();

        #region Constructors

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Descriptor()
        {
            ice_initialize();
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public Descriptor(SegmentType type)
        {
            this.type = type;
            ice_initialize();
        }

        #endregion

        private const string _id = "::LizardProtocol::Descriptor";

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static new string ice_staticId()
        {
            return _id;
        }
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override string ice_id()
        {
            return _id;
        }

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceWriteImpl(global::Ice.OutputStream ostr_)
        {
            ostr_.startSlice(ice_staticId(), -1, true);
            ostr_.writeEnum((int)type, 31);
            ostr_.endSlice();
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceReadImpl(global::Ice.InputStream istr_)
        {
            istr_.startSlice();
            type = (SegmentType)istr_.readEnum(31);
            istr_.endSlice();
        }

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

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int @base;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int limit;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public byte dpl;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public bool big;

        #endregion

        partial void ice_initialize();

        #region Constructors

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public SegmentDescriptor() : base()
        {
            ice_initialize();
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public SegmentDescriptor(SegmentType type, int @base, int limit, byte dpl, bool big) : base(type)
        {
            this.@base = @base;
            this.limit = limit;
            this.dpl = dpl;
            this.big = big;
            ice_initialize();
        }

        #endregion

        private const string _id = "::LizardProtocol::SegmentDescriptor";

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static new string ice_staticId()
        {
            return _id;
        }
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override string ice_id()
        {
            return _id;
        }

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceWriteImpl(global::Ice.OutputStream ostr_)
        {
            ostr_.startSlice(ice_staticId(), -1, false);
            ostr_.writeInt(@base);
            ostr_.writeInt(limit);
            ostr_.writeByte(dpl);
            ostr_.writeBool(big);
            ostr_.endSlice();
            base.iceWriteImpl(ostr_);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceReadImpl(global::Ice.InputStream istr_)
        {
            istr_.startSlice();
            @base = istr_.readInt();
            limit = istr_.readInt();
            dpl = istr_.readByte();
            big = istr_.readBool();
            istr_.endSlice();
            base.iceReadImpl(istr_);
        }

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

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public int offset;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public short selector;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public byte dpl;

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public bool big;

        #endregion

        partial void ice_initialize();

        #region Constructors

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public GateDescriptor() : base()
        {
            ice_initialize();
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public GateDescriptor(SegmentType type, int offset, short selector, byte dpl, bool big) : base(type)
        {
            this.offset = offset;
            this.selector = selector;
            this.dpl = dpl;
            this.big = big;
            ice_initialize();
        }

        #endregion

        private const string _id = "::LizardProtocol::GateDescriptor";

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public static new string ice_staticId()
        {
            return _id;
        }
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        public override string ice_id()
        {
            return _id;
        }

        #region Marshaling support

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceWriteImpl(global::Ice.OutputStream ostr_)
        {
            ostr_.startSlice(ice_staticId(), -1, false);
            ostr_.writeInt(offset);
            ostr_.writeShort(selector);
            ostr_.writeByte(dpl);
            ostr_.writeBool(big);
            ostr_.endSlice();
            base.iceWriteImpl(ostr_);
        }

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        protected override void iceReadImpl(global::Ice.InputStream istr_)
        {
            istr_.startSlice();
            offset = istr_.readInt();
            selector = istr_.readShort();
            dpl = istr_.readByte();
            big = istr_.readBool();
            istr_.endSlice();
            base.iceReadImpl(istr_);
        }

        #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 DebugHost : global::Ice.Object, DebugHostOperations_
    {
    }
}

namespace LizardProtocol
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugClient_Stopped();

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

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

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_Break(Registers ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_StepIn(Registers ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_StepOver(Registers ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_StepMultiple(Registers ret);

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

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_GetState(Registers ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_GetMaxNonEmptyAddress(int ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_SearchMemory(Address[] ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_Disassemble(AssemblyLine[] ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_GetMemory(byte[] ret);

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

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_ListBreakpoints(Breakpoint[] ret);

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

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

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

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

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_GetGdt(Descriptor[] ret);

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public delegate void Callback_DebugHost_GetLdt(Descriptor[] ret);
}

namespace LizardProtocol
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public interface DebugClientPrx : global::Ice.ObjectPrx
    {
        void Stopped(Registers state, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task StoppedAsync(Registers state, 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_DebugClient_Stopped> begin_Stopped(Registers state, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_Stopped(Registers state, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_Stopped(Registers state, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public interface DebugHostPrx : global::Ice.ObjectPrx
    {
        void Connect(DebugClientPrx proxy, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task ConnectAsync(DebugClientPrx proxy, 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_DebugHost_Connect> begin_Connect(DebugClientPrx proxy, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_Connect(DebugClientPrx proxy, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_Connect(DebugClientPrx proxy, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

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

        global::System.Threading.Tasks.Task ContinueAsync(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_DebugHost_Continue> begin_Continue(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

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

        Registers @Break(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Registers> BreakAsync(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_DebugHost_Break> begin_Break(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Registers end_Break(global::Ice.AsyncResult asyncResult);

        Registers StepIn(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Registers> StepInAsync(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_DebugHost_StepIn> begin_StepIn(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Registers end_StepIn(global::Ice.AsyncResult asyncResult);

        Registers StepOver(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Registers> StepOverAsync(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_DebugHost_StepOver> begin_StepOver(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Registers end_StepOver(global::Ice.AsyncResult asyncResult);

        Registers StepMultiple(int cycles, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Registers> StepMultipleAsync(int cycles, 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_DebugHost_StepMultiple> begin_StepMultiple(int cycles, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_StepMultiple(int cycles, global::Ice.AsyncCallback callback, object cookie);

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

        Registers end_StepMultiple(global::Ice.AsyncResult asyncResult);

        void RunToAddress(Address address, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task RunToAddressAsync(Address address, 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_DebugHost_RunToAddress> begin_RunToAddress(Address address, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_RunToAddress(Address address, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_RunToAddress(Address address, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

        Registers GetState(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Registers> GetStateAsync(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_DebugHost_GetState> begin_GetState(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Registers end_GetState(global::Ice.AsyncResult asyncResult);

        int GetMaxNonEmptyAddress(short seg, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<int> GetMaxNonEmptyAddressAsync(short seg, 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_DebugHost_GetMaxNonEmptyAddress> begin_GetMaxNonEmptyAddress(short seg, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_GetMaxNonEmptyAddress(short seg, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_GetMaxNonEmptyAddress(short seg, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

        int end_GetMaxNonEmptyAddress(global::Ice.AsyncResult asyncResult);

        Address[] SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Address[]> SearchMemoryAsync(Address start, int length, byte[] pattern, int advance, 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_DebugHost_SearchMemory> begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

        Address[] end_SearchMemory(global::Ice.AsyncResult asyncResult);

        AssemblyLine[] Disassemble(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<AssemblyLine[]> DisassembleAsync(Address address, int length, 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_DebugHost_Disassemble> begin_Disassemble(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_Disassemble(Address address, int length, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_Disassemble(Address address, int length, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

        AssemblyLine[] end_Disassemble(global::Ice.AsyncResult asyncResult);

        byte[] GetMemory(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<byte[]> GetMemoryAsync(Address address, int length, 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_DebugHost_GetMemory> begin_GetMemory(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_GetMemory(Address address, int length, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_GetMemory(Address address, int length, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

        byte[] end_GetMemory(global::Ice.AsyncResult asyncResult);

        void SetMemory(Address address, byte[] bytes, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task SetMemoryAsync(Address address, byte[] bytes, 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_DebugHost_SetMemory> begin_SetMemory(Address address, byte[] bytes, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_SetMemory(Address address, byte[] bytes, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_SetMemory(Address address, byte[] bytes, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

        Breakpoint[] ListBreakpoints(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Breakpoint[]> ListBreakpointsAsync(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_DebugHost_ListBreakpoints> begin_ListBreakpoints(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Breakpoint[] end_ListBreakpoints(global::Ice.AsyncResult asyncResult);

        void SetBreakpoint(Breakpoint breakpoint, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task SetBreakpointAsync(Breakpoint breakpoint, 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_DebugHost_SetBreakpoint> begin_SetBreakpoint(Breakpoint breakpoint, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_SetBreakpoint(Breakpoint breakpoint, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_SetBreakpoint(Breakpoint breakpoint, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

        void EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task EnableBreakpointAsync(int id, bool enabled, 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_DebugHost_EnableBreakpoint> begin_EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_EnableBreakpoint(int id, bool enabled, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

        void DelBreakpoint(int id, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task DelBreakpointAsync(int id, 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_DebugHost_DelBreakpoint> begin_DelBreakpoint(int id, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_DelBreakpoint(int id, global::Ice.AsyncCallback callback, object cookie);

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

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

        void SetRegister(Register reg, int value, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task SetRegisterAsync(Register reg, int value, 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_DebugHost_SetRegister> begin_SetRegister(Register reg, int value, global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::Ice.AsyncResult begin_SetRegister(Register reg, int value, global::Ice.AsyncCallback callback, object cookie);

        global::Ice.AsyncResult begin_SetRegister(Register reg, int value, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie);

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

        Descriptor[] GetGdt(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Descriptor[]> GetGdtAsync(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_DebugHost_GetGdt> begin_GetGdt(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Descriptor[] end_GetGdt(global::Ice.AsyncResult asyncResult);

        Descriptor[] GetLdt(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

        global::System.Threading.Tasks.Task<Descriptor[]> GetLdtAsync(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_DebugHost_GetLdt> begin_GetLdt(global::Ice.OptionalContext context = new global::Ice.OptionalContext());

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

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

        Descriptor[] end_GetLdt(global::Ice.AsyncResult asyncResult);
    }
}

namespace LizardProtocol
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public interface DebugClientOperations_
    {
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void Stopped(Registers state, global::Ice.Current current = null);
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public interface DebugHostOperations_
    {
        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void Connect(DebugClientPrx proxy, global::Ice.Current current = null);

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

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Registers @Break(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Registers StepIn(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Registers StepOver(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Registers StepMultiple(int cycles, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void RunToAddress(Address address, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Registers GetState(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        int GetMaxNonEmptyAddress(short seg, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Address[] SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        AssemblyLine[] Disassemble(Address address, int length, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        byte[] GetMemory(Address address, int length, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void SetMemory(Address address, byte[] bytes, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Breakpoint[] ListBreakpoints(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void SetBreakpoint(Breakpoint breakpoint, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void EnableBreakpoint(int id, bool enabled, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void DelBreakpoint(int id, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        void SetRegister(Register reg, int value, global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Descriptor[] GetGdt(global::Ice.Current current = null);

        [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
        Descriptor[] GetLdt(global::Ice.Current current = null);
    }
}

namespace LizardProtocol
{
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public sealed class ByteSequenceHelper
    {
        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.10")]
    public sealed class BreakpointSequenceHelper
    {
        public static void write(global::Ice.OutputStream ostr, Breakpoint[] 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 Breakpoint[] read(global::Ice.InputStream istr)
        {
            Breakpoint[] v;
            {
                int szx = istr.readAndCheckSeqSize(14);
                v = new Breakpoint[szx];
                for(int ix = 0; ix < szx; ++ix)
                {
                    v[ix].ice_readMembers(istr);
                }
            }
            return v;
        }
    }

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

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

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

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

        #region Synchronous operations

        public void Stopped(Registers state, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            try
            {
                _iceI_StoppedAsync(state, 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 StoppedAsync(Registers state, 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_StoppedAsync(state, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_StoppedAsync(Registers iceP_state, 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_Stopped(iceP_state, context, synchronous, completed);
            return completed.Task;
        }

        private const string _Stopped_name = "Stopped";

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

        #endregion

        #region Asynchronous operations

        public global::Ice.AsyncResult<Callback_DebugClient_Stopped> begin_Stopped(Registers state, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_Stopped(state, context, null, null, false);
        }

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

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

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

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

        #endregion

        #region Checked and unchecked cast operations

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

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

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

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

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

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

        private static readonly string[] _ids =
        {
            "::Ice::Object",
            "::LizardProtocol::DebugClient"
        };

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

        #endregion

        #region Marshaling support

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

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

        #endregion
    }

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

        public static Descriptor[] read(global::Ice.InputStream istr)
        {
            Descriptor[] v;
            {
                int szx = istr.readAndCheckSeqSize(1);
                v = new Descriptor[szx];
                for(int ix = 0; ix < szx; ++ix)
                {
                    istr.readValue(global::IceInternal.Patcher.arrayReadValue<Descriptor>(v, ix));
                }
            }
            return v;
        }
    }

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public sealed class AddressesHelper
    {
        public static void write(global::Ice.OutputStream ostr, Address[] 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 Address[] read(global::Ice.InputStream istr)
        {
            Address[] v;
            {
                int szx = istr.readAndCheckSeqSize(6);
                v = new Address[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.10")]
    [global::System.Serializable]
    public sealed class DebugHostPrxHelper : global::Ice.ObjectPrxHelperBase, DebugHostPrx
    {
        public DebugHostPrxHelper()
        {
        }

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

        #region Synchronous operations

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

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

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

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

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

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

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

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

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

        public Address[] SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            try
            {
                return _iceI_SearchMemoryAsync(start, length, pattern, advance, context, null, global::System.Threading.CancellationToken.None, true).Result;
            }
            catch(global::System.AggregateException ex_)
            {
                throw ex_.InnerException;
            }
        }

        public AssemblyLine[] Disassemble(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            try
            {
                return _iceI_DisassembleAsync(address, length, context, null, global::System.Threading.CancellationToken.None, true).Result;
            }
            catch(global::System.AggregateException ex_)
            {
                throw ex_.InnerException;
            }
        }

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

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

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

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

        public void EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            try
            {
                _iceI_EnableBreakpointAsync(id, enabled, context, null, global::System.Threading.CancellationToken.None, true).Wait();
            }
            catch(global::System.AggregateException ex_)
            {
                throw ex_.InnerException;
            }
        }

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

        public void SetRegister(Register reg, int value, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            try
            {
                _iceI_SetRegisterAsync(reg, value, context, null, global::System.Threading.CancellationToken.None, true).Wait();
            }
            catch(global::System.AggregateException ex_)
            {
                throw ex_.InnerException;
            }
        }

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

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

        #endregion

        #region Async Task operations

        public global::System.Threading.Tasks.Task ConnectAsync(DebugClientPrx proxy, 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_ConnectAsync(proxy, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_ConnectAsync(DebugClientPrx iceP_proxy, 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_Connect(iceP_proxy, context, synchronous, completed);
            return completed.Task;
        }

        private const string _Connect_name = "Connect";

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

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

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

        private const string _Continue_name = "Continue";

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

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

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

        private const string _Break_name = "Break";

        private void _iceI_Break(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Registers>(completed);
            outAsync.invoke(
                _Break_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Registers ret = new Registers();
                    ret.ice_readMembers(istr);
                    return ret;
                });
        }

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

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

        private const string _StepIn_name = "StepIn";

        private void _iceI_StepIn(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Registers>(completed);
            outAsync.invoke(
                _StepIn_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Registers ret = new Registers();
                    ret.ice_readMembers(istr);
                    return ret;
                });
        }

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

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

        private const string _StepOver_name = "StepOver";

        private void _iceI_StepOver(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Registers>(completed);
            outAsync.invoke(
                _StepOver_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Registers ret = new Registers();
                    ret.ice_readMembers(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<Registers> StepMultipleAsync(int cycles, 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_StepMultipleAsync(cycles, context, progress, cancel, false);
        }

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

        private const string _StepMultiple_name = "StepMultiple";

        private void _iceI_StepMultiple(int iceP_cycles, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Registers>(completed);
            outAsync.invoke(
                _StepMultiple_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    ostr.writeInt(iceP_cycles);
                },
                read: (global::Ice.InputStream istr) =>
                {
                    Registers ret = new Registers();
                    ret.ice_readMembers(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task RunToAddressAsync(Address address, 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_RunToAddressAsync(address, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_RunToAddressAsync(Address iceP_address, 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_RunToAddress(iceP_address, context, synchronous, completed);
            return completed.Task;
        }

        private const string _RunToAddress_name = "RunToAddress";

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

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

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

        private const string _GetState_name = "GetState";

        private void _iceI_GetState(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Registers>(completed);
            outAsync.invoke(
                _GetState_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Registers ret = new Registers();
                    ret.ice_readMembers(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<int> GetMaxNonEmptyAddressAsync(short seg, 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_GetMaxNonEmptyAddressAsync(seg, context, progress, cancel, false);
        }

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

        private const string _GetMaxNonEmptyAddress_name = "GetMaxNonEmptyAddress";

        private void _iceI_GetMaxNonEmptyAddress(short iceP_seg, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<int>(completed);
            outAsync.invoke(
                _GetMaxNonEmptyAddress_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    ostr.writeShort(iceP_seg);
                },
                read: (global::Ice.InputStream istr) =>
                {
                    int ret;
                    ret = istr.readInt();
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<Address[]> SearchMemoryAsync(Address start, int length, byte[] pattern, int advance, 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_SearchMemoryAsync(start, length, pattern, advance, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task<Address[]> _iceI_SearchMemoryAsync(Address iceP_start, int iceP_length, byte[] iceP_pattern, int iceP_advance, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
        {
            iceCheckTwowayOnly(_SearchMemory_name);
            var completed = new global::IceInternal.OperationTaskCompletionCallback<Address[]>(progress, cancel);
            _iceI_SearchMemory(iceP_start, iceP_length, iceP_pattern, iceP_advance, context, synchronous, completed);
            return completed.Task;
        }

        private const string _SearchMemory_name = "SearchMemory";

        private void _iceI_SearchMemory(Address iceP_start, int iceP_length, byte[] iceP_pattern, int iceP_advance, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Address[]>(completed);
            outAsync.invoke(
                _SearchMemory_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    iceP_start.ice_writeMembers(ostr);
                    ostr.writeInt(iceP_length);
                    ByteSequenceHelper.write(ostr, iceP_pattern);
                    ostr.writeInt(iceP_advance);
                },
                read: (global::Ice.InputStream istr) =>
                {
                    Address[] ret;
                    ret = AddressesHelper.read(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<AssemblyLine[]> DisassembleAsync(Address address, int length, 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_DisassembleAsync(address, length, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task<AssemblyLine[]> _iceI_DisassembleAsync(Address iceP_address, int iceP_length, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
        {
            iceCheckTwowayOnly(_Disassemble_name);
            var completed = new global::IceInternal.OperationTaskCompletionCallback<AssemblyLine[]>(progress, cancel);
            _iceI_Disassemble(iceP_address, iceP_length, context, synchronous, completed);
            return completed.Task;
        }

        private const string _Disassemble_name = "Disassemble";

        private void _iceI_Disassemble(Address iceP_address, int iceP_length, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<AssemblyLine[]>(completed);
            outAsync.invoke(
                _Disassemble_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    iceP_address.ice_writeMembers(ostr);
                    ostr.writeInt(iceP_length);
                },
                read: (global::Ice.InputStream istr) =>
                {
                    AssemblyLine[] ret;
                    ret = AssemblySequenceHelper.read(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<byte[]> GetMemoryAsync(Address address, int length, 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_GetMemoryAsync(address, length, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task<byte[]> _iceI_GetMemoryAsync(Address iceP_address, int iceP_length, global::Ice.OptionalContext context, global::System.IProgress<bool> progress, global::System.Threading.CancellationToken cancel, bool synchronous)
        {
            iceCheckTwowayOnly(_GetMemory_name);
            var completed = new global::IceInternal.OperationTaskCompletionCallback<byte[]>(progress, cancel);
            _iceI_GetMemory(iceP_address, iceP_length, context, synchronous, completed);
            return completed.Task;
        }

        private const string _GetMemory_name = "GetMemory";

        private void _iceI_GetMemory(Address iceP_address, int iceP_length, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<byte[]>(completed);
            outAsync.invoke(
                _GetMemory_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    iceP_address.ice_writeMembers(ostr);
                    ostr.writeInt(iceP_length);
                },
                read: (global::Ice.InputStream istr) =>
                {
                    byte[] ret;
                    ret = ByteSequenceHelper.read(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task SetMemoryAsync(Address address, byte[] bytes, 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_SetMemoryAsync(address, bytes, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_SetMemoryAsync(Address iceP_address, byte[] iceP_bytes, 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_SetMemory(iceP_address, iceP_bytes, context, synchronous, completed);
            return completed.Task;
        }

        private const string _SetMemory_name = "SetMemory";

        private void _iceI_SetMemory(Address iceP_address, byte[] iceP_bytes, global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<object>(completed);
            outAsync.invoke(
                _SetMemory_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                write: (global::Ice.OutputStream ostr) =>
                {
                    iceP_address.ice_writeMembers(ostr);
                    ByteSequenceHelper.write(ostr, iceP_bytes);
                });
        }

        public global::System.Threading.Tasks.Task<Breakpoint[]> ListBreakpointsAsync(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_ListBreakpointsAsync(context, progress, cancel, false);
        }

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

        private const string _ListBreakpoints_name = "ListBreakpoints";

        private void _iceI_ListBreakpoints(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Breakpoint[]>(completed);
            outAsync.invoke(
                _ListBreakpoints_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Breakpoint[] ret;
                    ret = BreakpointSequenceHelper.read(istr);
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task SetBreakpointAsync(Breakpoint breakpoint, 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_SetBreakpointAsync(breakpoint, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_SetBreakpointAsync(Breakpoint iceP_breakpoint, 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_SetBreakpoint(iceP_breakpoint, context, synchronous, completed);
            return completed.Task;
        }

        private const string _SetBreakpoint_name = "SetBreakpoint";

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

        public global::System.Threading.Tasks.Task EnableBreakpointAsync(int id, bool enabled, 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_EnableBreakpointAsync(id, enabled, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_EnableBreakpointAsync(int iceP_id, bool iceP_enabled, 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_EnableBreakpoint(iceP_id, iceP_enabled, context, synchronous, completed);
            return completed.Task;
        }

        private const string _EnableBreakpoint_name = "EnableBreakpoint";

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

        public global::System.Threading.Tasks.Task DelBreakpointAsync(int id, 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_DelBreakpointAsync(id, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_DelBreakpointAsync(int iceP_id, 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_DelBreakpoint(iceP_id, context, synchronous, completed);
            return completed.Task;
        }

        private const string _DelBreakpoint_name = "DelBreakpoint";

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

        public global::System.Threading.Tasks.Task SetRegisterAsync(Register reg, int value, 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_SetRegisterAsync(reg, value, context, progress, cancel, false);
        }

        private global::System.Threading.Tasks.Task _iceI_SetRegisterAsync(Register iceP_reg, int iceP_value, 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_SetRegister(iceP_reg, iceP_value, context, synchronous, completed);
            return completed.Task;
        }

        private const string _SetRegister_name = "SetRegister";

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

        public global::System.Threading.Tasks.Task<Descriptor[]> GetGdtAsync(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_GetGdtAsync(context, progress, cancel, false);
        }

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

        private const string _GetGdt_name = "GetGdt";

        private void _iceI_GetGdt(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Descriptor[]>(completed);
            outAsync.invoke(
                _GetGdt_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Descriptor[] ret;
                    ret = DescriptorsHelper.read(istr);
                    istr.readPendingValues();
                    return ret;
                });
        }

        public global::System.Threading.Tasks.Task<Descriptor[]> GetLdtAsync(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_GetLdtAsync(context, progress, cancel, false);
        }

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

        private const string _GetLdt_name = "GetLdt";

        private void _iceI_GetLdt(global::System.Collections.Generic.Dictionary<string, string> context, bool synchronous, global::IceInternal.OutgoingAsyncCompletionCallback completed)
        {
            var outAsync = getOutgoingAsync<Descriptor[]>(completed);
            outAsync.invoke(
                _GetLdt_name,
                global::Ice.OperationMode.Normal,
                global::Ice.FormatType.DefaultFormat,
                context,
                synchronous,
                read: (global::Ice.InputStream istr) =>
                {
                    Descriptor[] ret;
                    ret = DescriptorsHelper.read(istr);
                    istr.readPendingValues();
                    return ret;
                });
        }

        #endregion

        #region Asynchronous operations

        public global::Ice.AsyncResult<Callback_DebugHost_Connect> begin_Connect(DebugClientPrx proxy, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_Connect(proxy, context, null, null, false);
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        public global::Ice.AsyncResult<Callback_DebugHost_StepMultiple> begin_StepMultiple(int cycles, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_StepMultiple(cycles, context, null, null, false);
        }

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

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

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

        private global::Ice.AsyncResult<Callback_DebugHost_StepMultiple> begin_StepMultiple(int iceP_cycles, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_StepMultiple_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_StepMultiple, Registers>(
                (Callback_DebugHost_StepMultiple cb, Registers ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _StepMultiple_name, cookie, completedCallback);
            _iceI_StepMultiple(iceP_cycles, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_RunToAddress> begin_RunToAddress(Address address, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_RunToAddress(address, context, null, null, false);
        }

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

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

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

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

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

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

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

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

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

        public global::Ice.AsyncResult<Callback_DebugHost_GetMaxNonEmptyAddress> begin_GetMaxNonEmptyAddress(short seg, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_GetMaxNonEmptyAddress(seg, context, null, null, false);
        }

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

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

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

        private global::Ice.AsyncResult<Callback_DebugHost_GetMaxNonEmptyAddress> begin_GetMaxNonEmptyAddress(short iceP_seg, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_GetMaxNonEmptyAddress_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_GetMaxNonEmptyAddress, int>(
                (Callback_DebugHost_GetMaxNonEmptyAddress cb, int ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _GetMaxNonEmptyAddress_name, cookie, completedCallback);
            _iceI_GetMaxNonEmptyAddress(iceP_seg, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_SearchMemory> begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_SearchMemory(start, length, pattern, advance, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SearchMemory(start, length, pattern, advance, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SearchMemory(start, length, pattern, advance, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_SearchMemory> begin_SearchMemory(Address iceP_start, int iceP_length, byte[] iceP_pattern, int iceP_advance, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_SearchMemory_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_SearchMemory, Address[]>(
                (Callback_DebugHost_SearchMemory cb, Address[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _SearchMemory_name, cookie, completedCallback);
            _iceI_SearchMemory(iceP_start, iceP_length, iceP_pattern, iceP_advance, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_Disassemble> begin_Disassemble(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_Disassemble(address, length, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_Disassemble(Address address, int length, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_Disassemble(address, length, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_Disassemble(Address address, int length, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_Disassemble(address, length, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_Disassemble> begin_Disassemble(Address iceP_address, int iceP_length, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_Disassemble_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_Disassemble, AssemblyLine[]>(
                (Callback_DebugHost_Disassemble cb, AssemblyLine[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _Disassemble_name, cookie, completedCallback);
            _iceI_Disassemble(iceP_address, iceP_length, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_GetMemory> begin_GetMemory(Address address, int length, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_GetMemory(address, length, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_GetMemory(Address address, int length, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_GetMemory(address, length, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_GetMemory(Address address, int length, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_GetMemory(address, length, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_GetMemory> begin_GetMemory(Address iceP_address, int iceP_length, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_GetMemory_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_GetMemory, byte[]>(
                (Callback_DebugHost_GetMemory cb, byte[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _GetMemory_name, cookie, completedCallback);
            _iceI_GetMemory(iceP_address, iceP_length, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_SetMemory> begin_SetMemory(Address address, byte[] bytes, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_SetMemory(address, bytes, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_SetMemory(Address address, byte[] bytes, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SetMemory(address, bytes, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_SetMemory(Address address, byte[] bytes, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SetMemory(address, bytes, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_SetMemory> begin_SetMemory(Address iceP_address, byte[] iceP_bytes, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_SetMemory, object>(
                (Callback_DebugHost_SetMemory cb, object ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke();
                    }
                },
                this, _SetMemory_name, cookie, completedCallback);
            _iceI_SetMemory(iceP_address, iceP_bytes, context, synchronous, completed);
            return completed;
        }

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

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

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

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

        private global::Ice.AsyncResult<Callback_DebugHost_ListBreakpoints> begin_ListBreakpoints(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_ListBreakpoints_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_ListBreakpoints, Breakpoint[]>(
                (Callback_DebugHost_ListBreakpoints cb, Breakpoint[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _ListBreakpoints_name, cookie, completedCallback);
            _iceI_ListBreakpoints(context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_SetBreakpoint> begin_SetBreakpoint(Breakpoint breakpoint, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_SetBreakpoint(breakpoint, context, null, null, false);
        }

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

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

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

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

        public global::Ice.AsyncResult<Callback_DebugHost_EnableBreakpoint> begin_EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_EnableBreakpoint(id, enabled, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_EnableBreakpoint(int id, bool enabled, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_EnableBreakpoint(id, enabled, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_EnableBreakpoint(int id, bool enabled, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_EnableBreakpoint(id, enabled, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_EnableBreakpoint> begin_EnableBreakpoint(int iceP_id, bool iceP_enabled, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_EnableBreakpoint, object>(
                (Callback_DebugHost_EnableBreakpoint cb, object ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke();
                    }
                },
                this, _EnableBreakpoint_name, cookie, completedCallback);
            _iceI_EnableBreakpoint(iceP_id, iceP_enabled, context, synchronous, completed);
            return completed;
        }

        public global::Ice.AsyncResult<Callback_DebugHost_DelBreakpoint> begin_DelBreakpoint(int id, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_DelBreakpoint(id, context, null, null, false);
        }

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

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

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

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

        public global::Ice.AsyncResult<Callback_DebugHost_SetRegister> begin_SetRegister(Register reg, int value, global::Ice.OptionalContext context = new global::Ice.OptionalContext())
        {
            return begin_SetRegister(reg, value, context, null, null, false);
        }

        public global::Ice.AsyncResult begin_SetRegister(Register reg, int value, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SetRegister(reg, value, new global::Ice.OptionalContext(), callback, cookie, false);
        }

        public global::Ice.AsyncResult begin_SetRegister(Register reg, int value, global::Ice.OptionalContext context, global::Ice.AsyncCallback callback, object cookie)
        {
            return begin_SetRegister(reg, value, context, callback, cookie, false);
        }

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

        private global::Ice.AsyncResult<Callback_DebugHost_SetRegister> begin_SetRegister(Register iceP_reg, int iceP_value, global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_SetRegister, object>(
                (Callback_DebugHost_SetRegister cb, object ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke();
                    }
                },
                this, _SetRegister_name, cookie, completedCallback);
            _iceI_SetRegister(iceP_reg, iceP_value, context, synchronous, completed);
            return completed;
        }

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

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

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

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

        private global::Ice.AsyncResult<Callback_DebugHost_GetGdt> begin_GetGdt(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_GetGdt_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_GetGdt, Descriptor[]>(
                (Callback_DebugHost_GetGdt cb, Descriptor[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _GetGdt_name, cookie, completedCallback);
            _iceI_GetGdt(context, synchronous, completed);
            return completed;
        }

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

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

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

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

        private global::Ice.AsyncResult<Callback_DebugHost_GetLdt> begin_GetLdt(global::System.Collections.Generic.Dictionary<string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_GetLdt_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback<Callback_DebugHost_GetLdt, Descriptor[]>(
                (Callback_DebugHost_GetLdt cb, Descriptor[] ret) =>
                {
                    if(cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                this, _GetLdt_name, cookie, completedCallback);
            _iceI_GetLdt(context, synchronous, completed);
            return completed;
        }

        #endregion

        #region Checked and unchecked cast operations

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

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

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

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

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

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

        private static readonly string[] _ids =
        {
            "::Ice::Object",
            "::LizardProtocol::DebugHost"
        };

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

        #endregion

        #region Marshaling support

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

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

        #endregion
    }
}

namespace LizardProtocol
{
    [global::System.Runtime.InteropServices.ComVisible(false)]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.7.10")]
    public abstract class DebugClientDisp_ : global::Ice.ObjectImpl, DebugClient
    {
        #region Slice operations

        public abstract void Stopped(Registers state, global::Ice.Current current = null);

        #endregion

        #region Slice type-related members

        private static readonly string[] _ids =
        {
            "::Ice::Object",
            "::LizardProtocol::DebugClient"
        };

        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_Stopped(DebugClient obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Registers iceP_state;
            iceP_state = new Registers();
            iceP_state.ice_readMembers(istr);
            inS.endReadParams();
            obj.Stopped(iceP_state, current);
            return inS.setResult(inS.writeEmptyParams());
        }

        private static readonly string[] _all =
        {
            "Stopped",
            "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 iceD_Stopped(this, inS, current);
                }
                case 1:
                {
                    return global::Ice.ObjectImpl.iceD_ice_id(this, inS, current);
                }
                case 2:
                {
                    return global::Ice.ObjectImpl.iceD_ice_ids(this, inS, current);
                }
                case 3:
                {
                    return global::Ice.ObjectImpl.iceD_ice_isA(this, inS, current);
                }
                case 4:
                {
                    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.10")]
    public abstract class DebugHostDisp_ : global::Ice.ObjectImpl, DebugHost
    {
        #region Slice operations

        public abstract void Connect(DebugClientPrx proxy, global::Ice.Current current = null);

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

        public abstract Registers @Break(global::Ice.Current current = null);

        public abstract Registers StepIn(global::Ice.Current current = null);

        public abstract Registers StepOver(global::Ice.Current current = null);

        public abstract Registers StepMultiple(int cycles, global::Ice.Current current = null);

        public abstract void RunToAddress(Address address, global::Ice.Current current = null);

        public abstract Registers GetState(global::Ice.Current current = null);

        public abstract int GetMaxNonEmptyAddress(short seg, global::Ice.Current current = null);

        public abstract Address[] SearchMemory(Address start, int length, byte[] pattern, int advance, global::Ice.Current current = null);

        public abstract AssemblyLine[] Disassemble(Address address, int length, global::Ice.Current current = null);

        public abstract byte[] GetMemory(Address address, int length, global::Ice.Current current = null);

        public abstract void SetMemory(Address address, byte[] bytes, global::Ice.Current current = null);

        public abstract Breakpoint[] ListBreakpoints(global::Ice.Current current = null);

        public abstract void SetBreakpoint(Breakpoint breakpoint, global::Ice.Current current = null);

        public abstract void EnableBreakpoint(int id, bool enabled, global::Ice.Current current = null);

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

        public abstract void SetRegister(Register reg, int value, global::Ice.Current current = null);

        public abstract Descriptor[] GetGdt(global::Ice.Current current = null);

        public abstract Descriptor[] GetLdt(global::Ice.Current current = null);

        #endregion

        #region Slice type-related members

        private static readonly string[] _ids =
        {
            "::Ice::Object",
            "::LizardProtocol::DebugHost"
        };

        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_Connect(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            DebugClientPrx iceP_proxy;
            iceP_proxy = DebugClientPrxHelper.read(istr);
            inS.endReadParams();
            obj.Connect(iceP_proxy, 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_Continue(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            obj.@Continue(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_Break(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.@Break(current);
            var ostr = inS.startWriteParams();
            ret.ice_writeMembers(ostr);
            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_StepIn(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.StepIn(current);
            var ostr = inS.startWriteParams();
            ret.ice_writeMembers(ostr);
            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_StepOver(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.StepOver(current);
            var ostr = inS.startWriteParams();
            ret.ice_writeMembers(ostr);
            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_StepMultiple(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            int iceP_cycles;
            iceP_cycles = istr.readInt();
            inS.endReadParams();
            var ret = obj.StepMultiple(iceP_cycles, current);
            var ostr = inS.startWriteParams();
            ret.ice_writeMembers(ostr);
            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_RunToAddress(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Address iceP_address;
            iceP_address = new Address();
            iceP_address.ice_readMembers(istr);
            inS.endReadParams();
            obj.RunToAddress(iceP_address, 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_GetState(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.GetState(current);
            var ostr = inS.startWriteParams();
            ret.ice_writeMembers(ostr);
            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_GetMaxNonEmptyAddress(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            short iceP_seg;
            iceP_seg = istr.readShort();
            inS.endReadParams();
            var ret = obj.GetMaxNonEmptyAddress(iceP_seg, current);
            var ostr = inS.startWriteParams();
            ostr.writeInt(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_SearchMemory(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Address iceP_start;
            iceP_start = new Address();
            int iceP_length;
            byte[] iceP_pattern;
            int iceP_advance;
            iceP_start.ice_readMembers(istr);
            iceP_length = istr.readInt();
            iceP_pattern = ByteSequenceHelper.read(istr);
            iceP_advance = istr.readInt();
            inS.endReadParams();
            var ret = obj.SearchMemory(iceP_start, iceP_length, iceP_pattern, iceP_advance, current);
            var ostr = inS.startWriteParams();
            AddressesHelper.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_Disassemble(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Address iceP_address;
            iceP_address = new Address();
            int iceP_length;
            iceP_address.ice_readMembers(istr);
            iceP_length = istr.readInt();
            inS.endReadParams();
            var ret = obj.Disassemble(iceP_address, iceP_length, current);
            var ostr = inS.startWriteParams();
            AssemblySequenceHelper.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_GetMemory(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Address iceP_address;
            iceP_address = new Address();
            int iceP_length;
            iceP_address.ice_readMembers(istr);
            iceP_length = istr.readInt();
            inS.endReadParams();
            var ret = obj.GetMemory(iceP_address, iceP_length, current);
            var ostr = inS.startWriteParams();
            ByteSequenceHelper.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_SetMemory(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Address iceP_address;
            iceP_address = new Address();
            byte[] iceP_bytes;
            iceP_address.ice_readMembers(istr);
            iceP_bytes = ByteSequenceHelper.read(istr);
            inS.endReadParams();
            obj.SetMemory(iceP_address, iceP_bytes, 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_ListBreakpoints(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.ListBreakpoints(current);
            var ostr = inS.startWriteParams();
            BreakpointSequenceHelper.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_SetBreakpoint(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Breakpoint iceP_breakpoint;
            iceP_breakpoint = new Breakpoint();
            iceP_breakpoint.ice_readMembers(istr);
            inS.endReadParams();
            obj.SetBreakpoint(iceP_breakpoint, 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_EnableBreakpoint(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            int iceP_id;
            bool iceP_enabled;
            iceP_id = istr.readInt();
            iceP_enabled = istr.readBool();
            inS.endReadParams();
            obj.EnableBreakpoint(iceP_id, iceP_enabled, 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_DelBreakpoint(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            int iceP_id;
            iceP_id = istr.readInt();
            inS.endReadParams();
            obj.DelBreakpoint(iceP_id, 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_SetRegister(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            var istr = inS.startReadParams();
            Register iceP_reg;
            int iceP_value;
            iceP_reg = (Register)istr.readEnum(15);
            iceP_value = istr.readInt();
            inS.endReadParams();
            obj.SetRegister(iceP_reg, iceP_value, 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_GetGdt(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.GetGdt(current);
            var ostr = inS.startWriteParams();
            DescriptorsHelper.write(ostr, ret);
            ostr.writePendingValues();
            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_GetLdt(DebugHost obj, global::IceInternal.Incoming inS, global::Ice.Current current)
        {
            global::Ice.ObjectImpl.iceCheckMode(global::Ice.OperationMode.Normal, current.mode);
            inS.readEmptyParams();
            var ret = obj.GetLdt(current);
            var ostr = inS.startWriteParams();
            DescriptorsHelper.write(ostr, ret);
            ostr.writePendingValues();
            inS.endWriteParams(ostr);
            return inS.setResult(ostr);
        }

        private static readonly string[] _all =
        {
            "Break",
            "Connect",
            "Continue",
            "DelBreakpoint",
            "Disassemble",
            "EnableBreakpoint",
            "GetGdt",
            "GetLdt",
            "GetMaxNonEmptyAddress",
            "GetMemory",
            "GetState",
            "ListBreakpoints",
            "RunToAddress",
            "SearchMemory",
            "SetBreakpoint",
            "SetMemory",
            "SetRegister",
            "StepIn",
            "StepMultiple",
            "StepOver",
            "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 iceD_Break(this, inS, current);
                }
                case 1:
                {
                    return iceD_Connect(this, inS, current);
                }
                case 2:
                {
                    return iceD_Continue(this, inS, current);
                }
                case 3:
                {
                    return iceD_DelBreakpoint(this, inS, current);
                }
                case 4:
                {
                    return iceD_Disassemble(this, inS, current);
                }
                case 5:
                {
                    return iceD_EnableBreakpoint(this, inS, current);
                }
                case 6:
                {
                    return iceD_GetGdt(this, inS, current);
                }
                case 7:
                {
                    return iceD_GetLdt(this, inS, current);
                }
                case 8:
                {
                    return iceD_GetMaxNonEmptyAddress(this, inS, current);
                }
                case 9:
                {
                    return iceD_GetMemory(this, inS, current);
                }
                case 10:
                {
                    return iceD_GetState(this, inS, current);
                }
                case 11:
                {
                    return iceD_ListBreakpoints(this, inS, current);
                }
                case 12:
                {
                    return iceD_RunToAddress(this, inS, current);
                }
                case 13:
                {
                    return iceD_SearchMemory(this, inS, current);
                }
                case 14:
                {
                    return iceD_SetBreakpoint(this, inS, current);
                }
                case 15:
                {
                    return iceD_SetMemory(this, inS, current);
                }
                case 16:
                {
                    return iceD_SetRegister(this, inS, current);
                }
                case 17:
                {
                    return iceD_StepIn(this, inS, current);
                }
                case 18:
                {
                    return iceD_StepMultiple(this, inS, current);
                }
                case 19:
                {
                    return iceD_StepOver(this, inS, current);
                }
                case 20:
                {
                    return global::Ice.ObjectImpl.iceD_ice_id(this, inS, current);
                }
                case 21:
                {
                    return global::Ice.ObjectImpl.iceD_ice_ids(this, inS, current);
                }
                case 22:
                {
                    return global::Ice.ObjectImpl.iceD_ice_isA(this, inS, current);
                }
                case 23:
                {
                    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
    }
}
