<repo_name>abelectronicsuk/ABElectronics_Win10IOT_Libraries<file_sep>/ABElectronics_Win10IOT_Libraries/ExpanderPi.cs
﻿using System;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.Spi;
using Windows.Devices.I2c;
using Windows.Foundation.Metadata;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    /// Class Library for use with the Expander Pi
    /// </summary>
    public class ExpanderPi : IDisposable
    {
        // SPI Variables
        private const string SPI_CONTROLLER_NAME = "SPI0";
        private const Int32 ADC_CHIP_SELECT_LINE = 0; // ADC on SPI channel select CE0
        private const Int32 DAC_CHIP_SELECT_LINE = 1; // ADC on SPI channel select CE1

        // ADC Variables
        private SpiDevice adc;
        private double ADCReferenceVoltage = 4.096;

        // DAC Variables
        private SpiDevice dac;

        // IO Variables

        private readonly ABE_Helpers helper = new ABE_Helpers();

        // Define IO registers values from datasheet

        private const byte IODIRA = 0x00; // IO direction A
        private const byte IODIRB = 0x01; // IO direction B
        private const byte IPOLA = 0x02; // Input polarity A
        private const byte IPOLB = 0x03; // Input polarity B
        private const byte GPINTENA = 0x04; // Interrupt-on-change A
        private const byte GPINTENB = 0x05; // Interrupt-on-change B
        private const byte DEFVALA = 0x06; // Default value for port A
        private const byte DEFVALB = 0x07; // Default value for port B
        private const byte INTCONA = 0x08; // Interrupt control register for port A
        private const byte INTCONB = 0x09; // Interrupt control register for port B
        private const byte IOCON = 0x0A; // configuration register
        private const byte GPPUA = 0x0C; // pull-up resistors for port A
        private const byte GPPUB = 0x0D; // pull-up resistors for port B
        private const byte INTFA = 0x0E; // interrupt condition on port A
        private const byte INTFB = 0x0F; // interrupt condition on port B
        private const byte INTCAPA = 0x10; // captures the GPIO port A value at the time the interrupt occurred
        private const byte INTCAPB = 0x11; // captures the GPIO port B value at the time the interrupt occurred
        private const byte GPIOA = 0x12; // Data port A
        private const byte GPIOB = 0x13; // Data port B
        private const byte OLATA = 0x14; // Output latches A
        private const byte OLATB = 0x15; // Output latches B
        private const byte IOADDRESS = 0x20; // I2C Address for the MCP23017 IO chip

        private byte config = 0x22; // initial configuration - see IOCON page in the MCP23017 datasheet for more information.

        private I2cDevice IOi2cbus; // create an instance of the i2c bus
        private byte intA; // interrupt control for port a
        private byte intB; // interrupt control for port a

        // variables
        private byte port_a_dir; // port a direction
        private byte port_b_dir; // port b direction
        private byte porta_polarity; // input polarity for port a
        private byte porta_pullup; // port a pull-up resistors
        private byte portaval; // port a value
        private byte portb_polarity; // input polarity for port b
        private byte portb_pullup; // port a pull-up resistors
        private byte portbval; // port b value

        // RTC Variables

        private const byte RTCADDRESS = 0x68;
        private I2cDevice RTCi2cbus; // create an instance of the i2c bus

        // Register addresses for the DS1307 IC
        private const byte SECONDS = 0x00;
        private const byte MINUTES = 0x01;
        private const byte HOURS = 0x02;
        private const byte DAYOFWEEK = 0x03;
        private const byte DAY = 0x04;
        private const byte MONTH = 0x05;
        private const byte YEAR = 0x06;
        private const byte CONTROL = 0x07;

        // the DS1307 does not store the current century so that has to be added on manually.
        private readonly int century = 2000;

        // initial configuration - square wave and output disabled, frequency set to 32.768KHz.
        private byte rtcconfig = 0x03;

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);


        #region General Methods

        /// <summary>
        ///     Shows if there is a connection with the Expander Pi
        /// </summary>
        public bool IsConnected { get; private set; }

        /// <summary>
        ///     Create an instance of the Expander Pi.
        /// </summary>
        public ExpanderPi(){
            IsConnected = false;
        }


        /// <summary>
        ///     Open a connection to the Expander Pi.
        /// </summary>
        public async Task Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.Spi.SpiDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.I2c.I2cDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            try
            {
                
                // Create SPI initialization settings for the ADC
                var adcsettings =
                    new SpiConnectionSettings(ADC_CHIP_SELECT_LINE)
                    {
                        ClockFrequency = 1900000, // SPI clock frequency of 1.9MHz
                        Mode = SpiMode.Mode0
                    };
                
                var spiAqs = SpiDevice.GetDeviceSelector(SPI_CONTROLLER_NAME); // Find the selector string for the SPI bus controller
                var devicesInfo = await DeviceInformation.FindAllAsync(spiAqs); // Find the SPI bus controller device with our selector string

                if (devicesInfo.Count == 0)
                {
                    return; // Controller not found
                }

                adc = await SpiDevice.FromIdAsync(devicesInfo[0].Id, adcsettings); // Create an ADC connection with our bus controller and SPI settings

                // Create SPI initialization settings for the DAC
                var dacSettings =
                    new SpiConnectionSettings(DAC_CHIP_SELECT_LINE)
                    {
                        ClockFrequency = 2000000,  // SPI clock frequency of 20MHz
                        Mode = SpiMode.Mode0
                    };

                dac = await SpiDevice.FromIdAsync(devicesInfo[0].Id, dacSettings); // Create a DAC connection with our bus controller and SPI settings

                
                
                // Initialize the I2C bus 

                var aqs = I2cDevice.GetDeviceSelector(ABE_Helpers.I2C_CONTROLLER_NAME); // Find the selector string for the I2C bus controller
                var dis = await DeviceInformation.FindAllAsync(aqs); // Find the I2C bus controller device with our selector string

                if (dis.Count == 0)
                {
                    return; // Controller not found
                }

                var IOsettings = new I2cConnectionSettings(IOADDRESS) { BusSpeed = I2cBusSpeed.FastMode };

                var RTCsettings = new I2cConnectionSettings(RTCADDRESS) { BusSpeed = I2cBusSpeed.FastMode };

                IOi2cbus = await I2cDevice.FromIdAsync(dis[0].Id, IOsettings); // Create an IOI2cDevice with our selected bus controller and I2C settings
                RTCi2cbus = await I2cDevice.FromIdAsync(dis[0].Id, RTCsettings); // Create an RTCI2cDevice with our selected bus controller and I2C settings

                
                if (IOi2cbus != null && RTCi2cbus != null)
                {
                    // Set IsConnected to true
                    IsConnected = true;

                    // i2c bus is connected so set up the initial configuration for the IO Pi
                    helper.WriteI2CByte(IOi2cbus, IOCON, config);
                    
                    portaval = helper.ReadI2CByte(IOi2cbus, GPIOA);
                    portbval = helper.ReadI2CByte(IOi2cbus, GPIOB);
                    helper.WriteI2CByte(IOi2cbus, IODIRA, 0xFF);
                    helper.WriteI2CByte(IOi2cbus, IODIRB, 0xFF);
                    IOSetPortPullups(0, 0x00);
                    IOSetPortPullups(1, 0x00);
                    IOInvertPort(0, 0x00);
                    IOInvertPort(1, 0x00);

                    // Fire the Connected event handler
                    Connected?.Invoke(this, EventArgs.Empty);
                    

                }

                
            }
            /* If initialization fails, display the exception and stop running */
            catch (Exception ex)
            {
                IsConnected = false;
                throw new Exception("SPI and I2C Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }
#endregion

        #region ADC Methods


        /// <summary>
        ///     Read the voltage from the selected <paramref name="channel" /> on the ADC.
        /// </summary>
        /// <param name="channel">1 to 8</param>
        /// <param name="mode">1 = Single Ended Input, 2 = Differential Input</param>
        /// When in differential mode setting channel to 1 will make IN1 = IN+ and IN2 = IN-
        /// When in differential mode setting channel to 2 will make IN1 = IN- and IN2 = IN+
        /// When in differential mode setting channel to 3 will make IN3 = IN+ and IN4 = IN-
        /// When in differential mode setting channel to 4 will make IN3 = IN- and IN4 = IN+
        /// When in differential mode setting channel to 5 will make IN5 = IN+ and IN6 = IN-
        /// When in differential mode setting channel to 6 will make IN5 = IN- and IN6 = IN+
        /// When in differential mode setting channel to 7 will make IN7 = IN+ and IN8 = IN-
        /// When in differential mode setting channel to 8 will make IN7 = IN- and IN8 = IN+
        /// <returns>voltage</returns>
        public double ADCReadVoltage(byte channel, byte mode)
        {
            if (channel < 1 || channel > 8)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            var raw = ADCReadRaw(channel, mode);
            var voltage = ADCReferenceVoltage / 4096 * raw; // convert the raw value into a voltage based on the reference voltage.
            return voltage;
        }


        /// <summary>
        ///     Read the raw value from the selected <paramref name="channel" /> on the ADC.
        /// </summary>
        /// <param name="channel">1 to 8</param>
        /// <param name="mode">1 = Single Ended Input, 2 = Differential Input</param>
        /// When in differential mode setting channel to 1 will make IN1 = IN+ and IN2 = IN-
        /// When in differential mode setting channel to 2 will make IN1 = IN- and IN2 = IN+
        /// When in differential mode setting channel to 3 will make IN3 = IN+ and IN4 = IN-
        /// When in differential mode setting channel to 4 will make IN3 = IN- and IN4 = IN+
        /// When in differential mode setting channel to 5 will make IN5 = IN+ and IN6 = IN-
        /// When in differential mode setting channel to 6 will make IN5 = IN- and IN6 = IN+
        /// When in differential mode setting channel to 7 will make IN7 = IN+ and IN8 = IN-
        /// When in differential mode setting channel to 8 will make IN7 = IN- and IN8 = IN+
        /// <returns>Integer</returns>
        public int ADCReadRaw(byte channel, byte mode)
        {
            if (channel < 1 || channel > 8)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            CheckConnected();

            var writeArray = new byte[] { 0x00, 0x00, 0x00 };

            channel = (byte)(channel - 1);

            if (mode == 0)
            {
                writeArray[0] = (byte)(6 + (channel >> 2));
                writeArray[1] = (byte)((channel & 3) << 6);
            }
            else if (mode == 1)
            {
                writeArray[0] = (byte)(4 + (channel >> 2));
                writeArray[1] = (byte)((channel & 3) << 6);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(mode));
            }

            var readBuffer = new byte[3]; // this holds the output data

            adc.TransferFullDuplex(writeArray, readBuffer); // transfer the adc data

            var ret = (short)(((readBuffer[1] & 0x0F) << 8) + readBuffer[2]); // combine the two bytes into a single 16bit integer

            return ret;
        }

        /// <summary>
        ///     Set the reference <paramref name="voltage" /> for the analogue to digital converter.
        ///     The Expander Pi contains an onboard 4.096V voltage reference.  If you want to use an external
        ///     reference between 0V and 5V, disconnect the jumper J1 and connect your reference voltage to the Vref pin.
        /// </summary>
        /// <param name="voltage">double</param>
        public void ADCSetRefVoltage(double voltage)
        {
            CheckConnected();

            if (voltage < 0.0 || voltage > 5.0)
            {
                throw new ArgumentOutOfRangeException(nameof(voltage), "Reference voltage must be between 0.0V and 5.0V.");
            }

            ADCReferenceVoltage = voltage;
        }

        #endregion

        #region DAC Methods


        /// <summary>
        ///     Set the <paramref name="voltage" /> for the selected channel on the DAC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <param name="voltage">Voltage will be between 0 and 2.047V when gain is 1, 0 and 4.096V when gain is 2</param>
        /// <param name="gain">Gain can be 1 or 2</param>
        public void DACSetVoltage(byte channel, double voltage, byte gain)
        {
            // Check for valid channel and voltage variables
            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            if (gain < 1 || gain > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(gain));
            }

            if ((gain == 1 && (voltage >= 0.0 && voltage <= 2.048)) || (gain == 2 && (voltage >= 0.0 && voltage <= 4.096)))
            {
                var rawval = Convert.ToInt16(((voltage / 2.048) * 4096) / gain); // convert the voltage into a raw value
                DACSetRaw(channel, rawval, gain);
            }

            else
            {
                throw new ArgumentOutOfRangeException(nameof(voltage));
            }
        }

        /// <summary>
        ///     Set the raw <paramref name="value" /> from the selected <paramref name="channel" /> on the DAC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <param name="value">Value between 0 and 4095</param>
        /// <param name="gain">Gain can be 1 or 2</param>
        /// Voltage will be between 0 and 2.047V when gain is 1, 0 and 4.096V when gain is 2
        public void DACSetRaw(byte channel, short value, byte gain)
        {
            CheckConnected();

            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            if (value < 0 || value > 4095)
            {
                throw new ArgumentOutOfRangeException(nameof(value));
            }

            if (gain < 1 || gain > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(gain));
            }

            // split the raw value into two bytes and send it to the DAC.
            var lowByte = (byte)(value & 0xff);
            var highByte = (byte)0;

            if (gain == 1)
            {
                highByte = (byte)(((value >> 8) & 0xff) | ((channel - 1) << 7) | (1 << 5) | (1 << 4));
            }
            else
            {
                highByte = (byte)(((value >> 8) & 0xff) | ((channel - 1) << 7) | (1 << 4));
            }

            var writeBuffer = new[] { highByte, lowByte };
            dac.Write(writeBuffer);
        }

        #endregion

        #region IO Methods

        /// <summary>
        ///     Set IO <paramref name="direction" /> for an individual pin.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="direction">true = input, false = output</param>
        public void IOSetPinDirection(byte pin, bool direction)
        {
            CheckConnected();

            pin = (byte)(pin - 1);

            if (pin < 8)
            {
                port_a_dir = helper.UpdateByte(port_a_dir, pin, direction);
                helper.WriteI2CByte(IOi2cbus, IODIRA, port_a_dir);
            }
            else if (pin >= 8 && pin < 16)
            {
                port_b_dir = helper.UpdateByte(port_b_dir, (byte)(pin - 8), direction);
                helper.WriteI2CByte(IOi2cbus, IODIRB, port_b_dir);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Set the <paramref name="direction"/> for an IO <paramref name="port"/>.
        ///     You can control the direction of all 8 pins on a port by sending a single byte value.
        ///     Each bit in the byte represents one pin so for example 0x0A would set pins 2 and 4 to
        ///     inputs and all other pins to outputs.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="direction">Direction for all pins on the port.  1 = input, 0 = output</param>
        public void IOSetPortDirection(byte port, byte direction)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, IODIRA, direction);
                    port_a_dir = direction;
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, IODIRB, direction);
                    port_b_dir = direction;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Set the internal 100K pull-up resistors for an individual pin.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="value">true = enabled, false = disabled</param>
        public void IOSetPinPullup(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte)(pin - 1);

            if (pin < 8)
            {
                porta_pullup = helper.UpdateByte(porta_pullup, pin, value);
                helper.WriteI2CByte(IOi2cbus, GPPUA, porta_pullup);
            }
            else if (pin >= 8 && pin < 16)
            {
                portb_pullup = helper.UpdateByte(portb_pullup, (byte)(pin - 8), value);
                helper.WriteI2CByte(IOi2cbus, GPPUB, portb_pullup);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     set the internal 100K pull-up resistors for the selected IO port.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void IOSetPortPullups(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    porta_pullup = value;
                    helper.WriteI2CByte(IOi2cbus, GPPUA, value);
                    break;
                case 1:
                    portb_pullup = value;
                    helper.WriteI2CByte(IOi2cbus, GPPUB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Write to an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <param name="value">0 = logic low, 1 = logic high</param>
        public void IOWritePin(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                portaval = helper.UpdateByte(portaval, pin, value);
                helper.WriteI2CByte(IOi2cbus, GPIOA, portaval);
            }
            else if (pin >= 8 && pin < 16)
            {
                portbval = helper.UpdateByte(portbval, (byte)(pin - 8), value);
                helper.WriteI2CByte(IOi2cbus, GPIOB, portbval);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Write to all pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void IOWritePort(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, GPIOA, value);
                    portaval = value;
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, GPIOB, value);
                    portbval = value;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     read the value of an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <returns>0 = logic level low, 1 = logic level high</returns>
        public bool IOReadPin(byte pin)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                portaval = helper.ReadI2CByte(IOi2cbus, GPIOA);
                return helper.CheckBit(portaval, pin);
            }
            if (pin >= 8 && pin < 16)
            {
                portbval = helper.ReadI2CByte(IOi2cbus, GPIOB);
                return helper.CheckBit(portbval, (byte)(pin - 8));
            }
            throw new ArgumentOutOfRangeException(nameof(pin));
        }

        /// <summary>
        ///     Read all pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <returns>returns number between 0 and 255 or 0x00 and 0xFF</returns>
        public byte IOReadPort(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    portaval = helper.ReadI2CByte(IOi2cbus, GPIOA);
                    return portaval;
                case 1:
                    portbval = helper.ReadI2CByte(IOi2cbus, GPIOB);
                    return portbval;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Invert the polarity of the pins on a selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="polarity">0x00 - 0xFF (0 = same logic state of the input pin, 1 = inverted logic state of the input pin)</param>
        public void IOInvertPort(byte port, byte polarity)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, IPOLA, polarity);
                    porta_polarity = polarity;
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, IPOLB, polarity);
                    portb_polarity = polarity;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Invert the <paramref name="polarity" /> of the selected <paramref name="pin" />.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="polarity">False = same logic state of the input pin, True = inverted logic state of the input pin</param>
        public void IOInvertPin(byte pin, bool polarity)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                porta_polarity = helper.UpdateByte(portaval, pin, polarity);
                helper.WriteI2CByte(IOi2cbus, IPOLA, porta_polarity);
            }
            else if (pin >= 8 && pin < 16)
            {
                portb_polarity = helper.UpdateByte(portbval, (byte)(pin - 8), polarity);
                helper.WriteI2CByte(IOi2cbus, IPOLB, portb_polarity);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Sets the mirror status of the interrupt pins.
        /// </summary>
        /// <param name="value">
        ///     0 = The INT pins are not mirrored. INTA is associated with PortA and INTB is associated with PortB.
        ///     1 = The INT pins are internally connected
        /// </param>
        public void IOMirrorInterrupts(byte value)
        {
            CheckConnected();

            switch (value)
            {
                case 0:
                    config = helper.UpdateByte(config, 6, false);
                    helper.WriteI2CByte(IOi2cbus, IOCON, config);
                    break;
                case 1:
                    config = helper.UpdateByte(config, 6, true);
                    helper.WriteI2CByte(IOi2cbus, IOCON, config);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(value));
            }
        }

        /// <summary>
        ///     This sets the polarity of the INT output pins.
        /// </summary>
        /// <param name="value">1 = Active - high. 0 = Active - low.</param>
        public void IOSetInterruptPolarity(byte value)
        {
            CheckConnected();

            switch (value)
            {
                case 0:
                    config = helper.UpdateByte(config, 1, false);
                    helper.WriteI2CByte(IOi2cbus, IOCON, config);
                    break;
                case 1:
                    config = helper.UpdateByte(config, 1, true);
                    helper.WriteI2CByte(IOi2cbus, IOCON, config);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(value));
            }
        }

        /// <summary>
        ///     Sets the type of interrupt for each pin on the selected <paramref name="port"/>.
        ///     1 = interrupt is fired when the pin matches the default value.
        ///     0 = the interrupt is fired on state change.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void IOSetInterruptType(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, INTCONA, value);
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, INTCONB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     These bits set the compare value for pins configured for interrupt-on-change
        ///     on the selected <paramref name="port"/>. If the associated pin level is the
        ///     opposite from the register bit, an interrupt occurs.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void IOSetInterruptDefaults(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, DEFVALA, value);
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, DEFVALB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Enable interrupts for the pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void IOSetInterruptOnPort(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(IOi2cbus, GPINTENA, value);
                    intA = value;
                    break;
                case 1:
                    helper.WriteI2CByte(IOi2cbus, GPINTENB, value);
                    intB = value;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Enable interrupts for the selected <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="value">0 = interrupt disabled, 1 = interrupt enabled</param>
        public void IOSetInterruptOnPin(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                intA = helper.UpdateByte(intA, pin, value);
                helper.WriteI2CByte(IOi2cbus, GPINTENA, intA);
            }
            else if (pin >= 8 && pin < 16)
            {
                intB = helper.UpdateByte(intB, (byte)(pin - 8), value);
                helper.WriteI2CByte(IOi2cbus, GPINTENB, intB);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Read the interrupt status for the pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        public byte IOReadInterruptStatus(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    return helper.ReadI2CByte(IOi2cbus, INTFA);
                case 1:
                    return helper.ReadI2CByte(IOi2cbus, INTFB);
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Read the value from the selected <paramref name="port"/> at the time
        ///     of the last interrupt trigger.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        public byte IOReadInterruptCapture(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    return helper.ReadI2CByte(IOi2cbus, INTCAPA);
                case 1:
                    return helper.ReadI2CByte(IOi2cbus, INTCAPB);
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Reset the interrupts A and B to 0.
        /// </summary>
        public void IOResetInterrupts()
        {
            CheckConnected();

            IOReadInterruptCapture(0);
            IOReadInterruptCapture(1);
        }
#endregion

        #region RTC Methods        

        /// <summary>
        ///     Converts BCD format to integer.
        /// </summary>
        /// <param name="x">BCD formatted byte</param>
        /// <returns></returns>
        private int BCDtoInt(byte x)
        {
            return x - 6 * (x >> 4);
        }

        /// <summary>
        ///     Converts byte to BCD format.
        /// </summary>
        /// <param name="val">value to convert</param>
        /// <returns>Converted byte</returns>
        private byte BytetoBCD(int val)
        {
            return (byte)(val / 10 * 16 + val % 10);
        }


        /// <summary>
        ///     Set the date and time on the RTC.
        /// </summary>
        /// <param name="date">DateTime</param>
        public void RTCSetDate(DateTime date)
        {
            CheckConnected();

            helper.WriteI2CByte(RTCi2cbus, SECONDS, BytetoBCD(date.Second));
            helper.WriteI2CByte(RTCi2cbus, MINUTES, BytetoBCD(date.Minute));
            helper.WriteI2CByte(RTCi2cbus, HOURS, BytetoBCD(date.Hour));
            helper.WriteI2CByte(RTCi2cbus, DAYOFWEEK, BytetoBCD((int)date.DayOfWeek));
            helper.WriteI2CByte(RTCi2cbus, DAY, BytetoBCD(date.Day));
            helper.WriteI2CByte(RTCi2cbus, MONTH, BytetoBCD(date.Month));
            helper.WriteI2CByte(RTCi2cbus, YEAR, BytetoBCD(date.Year - century));
        }

        /// <summary>
        ///     Read the date and time from the RTC.
        /// </summary>
        /// <returns>DateTime</returns>
        public DateTime RTCReadDate()
        {
            CheckConnected();

            var DateArray = helper.ReadI2CBlockData(RTCi2cbus, 0, 7);
            var year = BCDtoInt(DateArray[6]) + century;
            var month = BCDtoInt(DateArray[5]);
            var day = BCDtoInt(DateArray[4]);
            // var dayofweek = BCDtoInt(DateArray[3]);
            var hours = BCDtoInt(DateArray[2]);
            var minutes = BCDtoInt(DateArray[1]);
            var seconds = BCDtoInt(DateArray[0]);

            try
            {
                var date = new DateTime(year, month, day, hours, minutes, seconds);
                return date;
            }
            catch
            {
                var date = new DateTime(1990, 01, 01, 01, 01, 01);
                return date;
            }
        }

        /// <summary>
        ///     Enable the clock output pin.
        /// </summary>
        public void RTCEnableOutput()
        {
            CheckConnected();

            rtcconfig = helper.UpdateByte(rtcconfig, 7, true);
            rtcconfig = helper.UpdateByte(rtcconfig, 4, true);
            helper.WriteI2CByte(RTCi2cbus, CONTROL, rtcconfig);
        }

        /// <summary>
        ///     Disable the clock output pin.
        /// </summary>
        public void RTCDisableOutput()
        {
            CheckConnected();

            rtcconfig = helper.UpdateByte(rtcconfig, 7, false);
            rtcconfig = helper.UpdateByte(rtcconfig, 4, false);
            helper.WriteI2CByte(RTCi2cbus, CONTROL, rtcconfig);
        }

        /// <summary>
        ///     Set the frequency of the output pin square-wave.
        /// </summary>
        /// <param name="frequency">options are: 1 = 1Hz, 2 = 4.096KHz, 3 = 8.192KHz, 4 = 32.768KHz</param>
        public void RTCSetFrequency(byte frequency)
        {
            CheckConnected();

            switch (frequency)
            {
                case 1:
                    rtcconfig = helper.UpdateByte(rtcconfig, 0, false);
                    rtcconfig = helper.UpdateByte(rtcconfig, 1, false);
                    break;
                case 2:
                    rtcconfig = helper.UpdateByte(rtcconfig, 0, true);
                    rtcconfig = helper.UpdateByte(rtcconfig, 1, false);
                    break;
                case 3:
                    rtcconfig = helper.UpdateByte(rtcconfig, 0, false);
                    rtcconfig = helper.UpdateByte(rtcconfig, 1, true);
                    break;
                case 4:
                    rtcconfig = helper.UpdateByte(rtcconfig, 0, true);
                    rtcconfig = helper.UpdateByte(rtcconfig, 1, true);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(frequency));
            }
            helper.WriteI2CByte(RTCi2cbus, CONTROL, rtcconfig);
        }

        #endregion

        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                adc?.Dispose();
                adc = null;

                dac?.Dispose();
                dac = null;

                IOi2cbus?.Dispose();
                IOi2cbus = null;

                RTCi2cbus?.Dispose();
                RTCi2cbus = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }

    }
}
<file_sep>/ABElectronics_Win10IOT_Libraries/ADCDACPi.cs
﻿using System;
using Windows.Devices.Enumeration;
using Windows.Devices.Spi;
using Windows.Foundation.Metadata;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    ///     Class for accessing the ADCDAC Pi from AB Electronics UK.
    /// </summary>
    public class ADCDACPi : IDisposable
    {
        private const string SPI_CONTROLLER_NAME = "SPI0";
        private const Int32 ADC_CHIP_SELECT_LINE = 0; // ADC on SPI channel select CE0
        private const Int32 DAC_CHIP_SELECT_LINE = 1; // ADC on SPI channel select CE1

        private SpiDevice adc;
        private double ADCReferenceVoltage = 3.3;
        private SpiDevice dac;

        /// <summary>
        ///     Event triggers when a connection is established.
        /// </summary>
        public bool IsConnected { get; private set; }

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

        /// <summary>
        ///     Open a connection to the ADCDAC Pi.
        /// </summary>
        public async void Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if(!ApiInformation.IsTypePresent("Windows.Devices.Spi.SpiDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            try
            {
                // Create SPI initialization settings for the ADC
                var adcsettings =
                    new SpiConnectionSettings(ADC_CHIP_SELECT_LINE)
                    {
                        ClockFrequency = 10000000, // SPI clock frequency of 10MHz
                        Mode = SpiMode.Mode0
                    };


                var spiAqs = SpiDevice.GetDeviceSelector(SPI_CONTROLLER_NAME); // Find the selector string for the SPI bus controller
                var devicesInfo = await DeviceInformation.FindAllAsync(spiAqs); // Find the SPI bus controller device with our selector string

                if (devicesInfo.Count == 0)
                {
                    return; // Controller not found
                }

                adc = await SpiDevice.FromIdAsync(devicesInfo[0].Id, adcsettings); // Create an ADC connection with our bus controller and SPI settings

                // Create SPI initialization settings for the DAC
                var dacSettings =
                    new SpiConnectionSettings(DAC_CHIP_SELECT_LINE)
                    {
                        ClockFrequency = 2000000,  // SPI clock frequency of 20MHz
                        Mode = SpiMode.Mode0
                    };

                dac = await SpiDevice.FromIdAsync(devicesInfo[0].Id, dacSettings); // Create a DAC connection with our bus controller and SPI settings

                IsConnected = true; // connection established, set IsConnected to true.

                // Fire the Connected event handler
                Connected?.Invoke(this, EventArgs.Empty);
            }
            /* If initialization fails, display the exception and stop running */
            catch (Exception ex)
            {
                IsConnected = false;
                throw new Exception("SPI Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;

        /// <summary>
        ///     Read the voltage from the selected <paramref name="channel" /> on the ADC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <returns>voltage</returns>
        public double ReadADCVoltage(byte channel)
        {
            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            var raw = ReadADCRaw(channel);
            var voltage = ADCReferenceVoltage / 4096 * raw; // convert the raw value into a voltage based on the reference voltage.
            return voltage;
        }


        /// <summary>
        ///     Read the raw value from the selected <paramref name="channel" /> on the ADC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <returns>Integer</returns>
        public int ReadADCRaw(byte channel)
        {
            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            CheckConnected();

            var writeArray = new byte[] { 0x01, (byte) ((1 + channel) << 6), 0x00}; // create the write bytes based on the input channel

            var readBuffer = new byte[3]; // this holds the output data

            adc.TransferFullDuplex(writeArray, readBuffer); // transfer the adc data

            var ret = (short) (((readBuffer[1] & 0x0F) << 8) + readBuffer[2]); // combine the two bytes into a single 16bit integer

            return ret;
        }

        /// <summary>
        ///     Set the reference <paramref name="voltage" /> for the analogue to digital converter.
        ///     The ADC uses the raspberry pi 3.3V power as a <paramref name="voltage" /> reference
        ///     so using this method to set the reference to match the exact output 
        ///     <paramref name="voltage" /> from the 3.3V regulator will increase the accuracy of
        ///     the ADC readings.
        /// </summary>
        /// <param name="voltage">double</param>
        public void SetADCrefVoltage(double voltage)
        {
            CheckConnected();

            if (voltage < 0.0 || voltage > 7.0)
            {
                throw new ArgumentOutOfRangeException(nameof(voltage), "Reference voltage must be between 0.0V and 7.0V.");
            }

            ADCReferenceVoltage = voltage;
        }

        /// <summary>
        ///     Set the <paramref name="voltage" /> for the selected channel on the DAC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <param name="voltage">Voltage can be between 0 and 2.047 volts</param>
        public void SetDACVoltage(byte channel, double voltage)
        {
            // Check for valid channel and voltage variables
            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (voltage >= 0.0 && voltage < 2.048)
            {
                var rawval = Convert.ToInt16(voltage / 2.048 * 4096); // convert the voltage into a raw value
                SetDACRaw(channel, rawval);
            }
            else
            {
                throw new ArgumentOutOfRangeException();
            }
        }

        /// <summary>
        ///     Set the raw <paramref name="value" /> from the selected <paramref name="channel" /> on the DAC.
        /// </summary>
        /// <param name="channel">1 or 2</param>
        /// <param name="value">Value between 0 and 4095</param>
        public void SetDACRaw(byte channel, short value)
        {
            CheckConnected();

            if (channel < 1 || channel > 2)
            {
                throw new ArgumentOutOfRangeException();
            }

            // split the raw value into two bytes and send it to the DAC.
            var lowByte = (byte) (value & 0xff);
            var highByte = (byte) (((value >> 8) & 0xff) | ((channel - 1) << 7) | (0x1 << 5) | (1 << 4));
            var writeBuffer = new [] { highByte, lowByte};
            dac.Write(writeBuffer);
        }

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }

        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                adc?.Dispose();
                adc = null;

                dac?.Dispose();
                dac = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }
    }
}<file_sep>/DemoApplication/RTCPi.xaml.cs
﻿using System;
using System.Threading;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;



namespace DemoApplication
{
    /// <summary>
    /// This demonstration shows how to use the RTC Pi class to read and set a date and time
    /// </summary>
    public sealed partial class RTCPi : Page
    {
        // create an instance of the RTCPi class called rtc
        ABElectronics_Win10IOT_Libraries.RTCPi rtc = new ABElectronics_Win10IOT_Libraries.RTCPi();

        // a timer will be used to read from the RTC Pi at 1 second intervals
        Timer _timer;

        public RTCPi()
        {
            this.InitializeComponent();

        }

        private async void bt_Connect_Click(object sender, RoutedEventArgs e)
        {
            // when the connect button is clicked check that the RTC Pi is not already connected before creating a Connected event handler and connecting to the RTC Pi
            if (!rtc.IsConnected)
            {
                rtc.Connected += Rtc_Connected;
                await rtc.Connect();
            }
        }

        private void Rtc_Connected(object sender, EventArgs e)
        {
            // a connection has been established so start the timer to read the date from the RTC Pi
            _timer = new Timer(Timer_Tick, null, 1000, Timeout.Infinite);
        }

        private async void Timer_Tick(object state)
        {
            // check that the RTC Pi is still connected
            if (rtc.IsConnected)
            {
                try {
                    // read the current date and time from the RTC Pi into a DateTime object
                    DateTime date = rtc.ReadDate();

                    // invoke a dispatcher to update the date textbox on the page
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        txt_Date.Text = date.ToString("d MMMM yyyy hh:mm:ss tt");
                    });
                }
                catch
                {
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        txt_Date.Text = "Error reading date";
                    });
                }
            }
            _timer.Change(1000, Timeout.Infinite);
        }

        private void bt_SetDate_Click(object sender, RoutedEventArgs e)
        {
            if (rtc.IsConnected)
            {
                // create a new DateTime object using the values from the Date and Time pickers
                DateTime newdate = new DateTime(picker_NewDate.Date.Year, picker_NewDate.Date.Month, picker_NewDate.Date.Day, picker_NewTime.Time.Hours, picker_NewTime.Time.Minutes, picker_NewTime.Time.Seconds);

                // update the RTC Pi with the new DateTime object
                rtc.SetDate(newdate);
            }
        }

        private void cb_sqw_clicked(object sender, RoutedEventArgs e)
        {
            // check the value for the SQW checkbox and enable or disable the square wave output pin
            if (rtc.IsConnected)
            {
                if (cb_sqw.IsChecked == true)
                {
                    radio_frequency_clicked(null, null);
                    rtc.EnableOutput();
                }
                else
                {
                    rtc.DisableOutput();
                }

            }
        }

        private void radio_frequency_clicked(object sender, RoutedEventArgs e)
        {
            // check which frequency radio button has been clicked and update the frequency for the square wave output
            if (rtc.IsConnected)
            {
                if (radio_frequency1.IsChecked == true)
                {
                    rtc.SetFrequency(1);
                }
                if (radio_frequency2.IsChecked == true)
                {
                    rtc.SetFrequency(2);
                }
                if (radio_frequency3.IsChecked == true)
                {
                    rtc.SetFrequency(3);
                }
                if (radio_frequency4.IsChecked == true)
                {
                    rtc.SetFrequency(4);
                }

            }
        }


        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // dispose of the rtc object and go back to the main page
            try
            {
                rtc.Dispose();
            }
            catch { }
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }

        
    }
}
<file_sep>/README.md
# AB Electronics UK Windows 10 IOT Libraries and Demos #

This is the Windows 10 IOT Library to work with Raspberry Pi expansion boards from <https://www.abelectronics.co.uk>.

The AB Electronics Windows 10 IOT Library in the ABElectronics_Win10IOT_Libraries directory contains classes for the following Raspberry Pi expansion boards:

**This library is not compatible with the direct memory mapped driver (DMAP).**

## Installing The Library ##

To install ABElectronics-Windows10-IOT, run the following command in the Package Manager Console 
``` powershell
Install-Package ABElectronics_Win10IOT_Libraries 
```
The library is available from [NuGet](https://www.nuget.org/packages/ABElectronics_Win10IOT_Libraries/).

## Boards ##
### ADC-DAC Pi ###
<https://www.abelectronics.co.uk/products/3/Raspberry-Pi/39/ADC-DAC-Pi-Raspberry-Pi-ADC-and-DAC-expansion-board>

### ADC Pi, ADC Pi Zero and ADC Pi Plus ###
- RP A+, B+, 2, 3 & Zero: <https://www.abelectronics.co.uk/p/69/ADC-Pi-Raspberry-Pi-Analogue-to-Digital-converter>

### Delta Sigma Pi and ADC Differential Pi ###
- RP A+, B+, 2 & 3: <https://www.abelectronics.co.uk/p/65/ADC-Differential-Pi-Raspberry-Pi-Analogue-to-Digital-converter>

### Expander Pi ###
- RP Zero, A+, B+, 2 & 3: <https://www.abelectronics.co.uk/p/50/Expander-Pi>

### IO Pi, IO Pi Zero and IO Pi Plus ###
- RP Pi Zero: <https://www.abelectronics.co.uk/p/71/IO-Pi-Zero>*
- RP A+, B+, 2 & 3: <https://www.abelectronics.co.uk/p/54/IO-Pi-Plus>

### RTC Pi, RTC Pi Zero and RTC Pi Plus ###
- RP Pi Zero: <https://www.abelectronics.co.uk/p/70/RTC-Pi-Zero>*
- RP A+, B+, 2 & 3: <https://www.abelectronics.co.uk/p/52/RTC-Pi-Plus>

### Servo Pi Zero and Servo Pi ###
- RP Pi Zero: <https://www.abelectronics.co.uk/p/72/Servo-PWM-Pi-Zero>*
- RP A+, B+, 2 & 3: <https://www.abelectronics.co.uk/p/44/Servo-PWM-Pi>

> \* Note: Windows 10 IoT won't work on Pi Zero because it's ARMv6. ARMv7+ is required for Windows.

## Demo Applications ##

- The "**DemoApplication**" directory contains a sample GUI application to connect to each of the supported boards and get and set data.
-- The project/solution is written for Visual Studio 2015 running under Windows 10.

If you are not using the Nuget version, you'll need to include the following dll file as a reference in your project:
`ABElectronics_Win10IOT_Libraries\bin\ARM\Release\ABElectronics_Win10IOT_Libraries.dll`.
<file_sep>/ABElectronics_Win10IOT_Libraries/README.md
AB Electronics Windows 10 IOT Libraries
=====

Windows 10 IOT Library to use with Raspberry Pi expansion boards from https://www.abelectronics.co.uk

The AB Electronics Windows 10 IOT Library contains the following classes:

# ADCDACPi
This class contains methods for use with the ADC DAC Pi and ADC DAC Pi Zero from  https://www.abelectronics.co.uk/p/74/ADC-DAC-Pi-Zero-Raspberry-Pi-ADC-and-DAC-expansion-board

## Methods:

```
ReadADCVoltage(byte channel)
```
Read the voltage from the selected channel on the ADC  
**Parameters:** channel - 1 or 2  
**Returns:** number as float between 0 and 2.048

```
ReadADCRaw(byte channel)
```
Read the raw value from the selected channel on the ADC  
**Parameters:** channel - 1 or 2  
**Returns:** int
```
SetADCrefVoltage(double voltage) 
```
Set the reference voltage for the analogue to digital converter.  
The ADC uses the raspberry pi 3.3V power as a voltage reference so using this method to set the reference to match the exact output voltage from the 3.3V regulator will increase the accuracy of the ADC readings.  
**Parameters:** voltage - double between 0.0 and 7.0  
**Returns:** null

```
SetDACVoltage(byte channel, double voltage)
```
Set the voltage for the selected channel on the DAC  
**Parameters:** channel - 1 or 2,  voltage can be between 0 and 2.047 volts  
**Returns:** null 

```
SetDACRaw(byte channel, int value)
```
Set the raw value from the selected channel on the DAC  
**Parameters:** channel - 1 or 2,value int between 0 and 4095  
**Returns:** null 
## Usage

To use the ADCDACPi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the ADCDACPi class:
```
ABElectronics_Win10IOT_Libraries.ADCDACPi adcdac = new ABElectronics_Win10IOT_Libraries.ADCDACPi();
```
Next we need to connect to the device and wait for the connection
```
adcdac.Connect();

while (!adcdac.IsConnected)
{
}

```
Set the reference voltage.
```
adcdac.SetADCrefVoltage(3.3);
```
Read the voltage from channel 2
```
double value = adcdac.ReadADCVoltage(2);
```

Set the DAC voltage on channel 2 to 1.5 volts
```
adcdac.SetDACVoltage(2, 1.5);
```

# ADCPi 
This class contains methods for use with the  ADC Pi, ADC Pi Plus and ADC Pi Zero from  https://www.abelectronics.co.uk/p/56/ADC-Pi-Plus-Raspberry-Pi-Analogue-to-Digital-converter  
https://www.abelectronics.co.uk/p/69/ADC-Pi-Zero-Raspberry-Pi-Analogue-to-Digital-converter  

## Methods:
```
Connect() 
```
Connect to the I2C device  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected  
**Parameters:** none  
**Returns:** boolean  
```
Dispose() 
```
Dispose of the active I2C device  
**Parameters:** none  
**Returns:** null  
```
ReadVoltage(byte channel)
```
Read the voltage from the selected channel  
**Parameters:** channel as int - 1 to 8  
**Returns:** number as double between 0 and 5.0  

```
ReadRaw(byte channel)
```
Read the raw int value from the selected channel  
**Parameters:** channel as int - 1 to 8  
**Returns:** raw integer value from ADC buffer  

```
SetPGA(byte gain)
```
Set the gain of the PDA on the chip  
**Parameters:** gain as int -  1, 2, 4, 8  
**Returns:** null  

```
SetBitRate(byte rate)
```
Set the sample bit rate of the adc  
**Parameters:** rate as int -  12, 14, 16, 18  
**Returns:** null  
12 = 12 bit (240SPS max)  
14 = 14 bit (60SPS max)  
16 = 16 bit (15SPS max)  
18 = 18 bit (3.75SPS max)  

```
SetConversionMode(bool mode)
```
Set the conversion mode for the adc  
**Parameters:** mode as boolean -  false = One-shot conversion, true = Continuous conversion  
**Returns:** null

## Usage

To use the ADC Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the adc class:
```
ABElectronics_Win10IOT_Libraries.ADCPi adc = new ADCPi(0x68, 0x69);
```
The arguments are the two I2C addresses of the ADC chips. The values shown are the default addresses of the ADC board.

Next we need to connect to the device and wait for the connection before setting the bit rate and gain. The sample rate can be 12, 14, 16 or 18
```
adc.Connect();

while (!adc.IsConnected)
{
}
adc.SetBitRate(18);
adc.SetPGA(1);

```

You can now read the voltage from channel 1 with:
```
double readvalue = 0;

readvalue = adc.ReadVoltage(1);
```


# ADCDifferentialPi
This class contains methods for use with the ADC Differential Pi from https://www.abelectronics.co.uk/p/65/ADC-Differential-Pi-Raspberry-Pi-Analogue-to-Digital-converter

## Methods:
```
Connect() 
```
Connect to the I2C device  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected
**Parameters:** none  
**Returns:** boolean  

```
Dispose() 
```
Dispose of the active I2C device  
**Parameters:** none  
**Returns:** null  

```
ReadVoltage(byte channel)
```
Read the voltage from the selected channel  
**Parameters:** channel as int - 1 to 8  
**Returns:** number as double between 0 and 5.0  

```
ReadRaw(byte channel)
```
Read the raw int value from the selected channel  
**Parameters:** channel as int - 1 to 8  
**Returns:** raw integer value from ADC buffer  

```
SetPGA(byte gain)
```
Set the gain of the PDA on the chip  
**Parameters:** gain as int -  1, 2, 4, 8  
**Returns:** null

```
SetBitRate(byte rate)
```
Set the sample bit rate of the adc  
**Parameters:** rate as int -  12, 14, 16, 18  
**Returns:** null  
12 = 12 bit (240SPS max)  
14 = 14 bit (60SPS max)  
16 = 16 bit (15SPS max)  
18 = 18 bit (3.75SPS max)  

```
SetConversionMode(bool mode)
```
Set the conversion mode for the adc  
**Parameters:** mode as boolean -  false = One-shot conversion, true = Continuous conversion  
**Returns:** null

### Usage

To use the Delta Sigma Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the adc class:
```
ABElectronics_Win10IOT_Libraries.DeltaSigmaPi adc = new DeltaSigmaPi(0x68, 0x69);
```
The arguments are the two I2C addresses of the ADC chips. The values shown are the default addresses of the Delta Sigma Pi board.

Next we need to connect to the device and wait for the connection before setting the bit rate and gain. The sample rate can be 12, 14, 16 or 18
```
adc.Connect();

while (!adc.IsConnected)
{
}
adc.SetBitRate(18);
adc.SetPGA(1);

```

You can now read the voltage from channel 1 with:
```
double readvalue = 0;

readvalue = adc.ReadVoltage(1);
```

# ExpanderPi
This class contains methods to use with the Expander Pi from
https://www.abelectronics.co.uk/p/50/Expander-Pi

**Note:** Microchip recommends that digital pins 8 (GPA7) and 16 (GPB7) are used as outputs only.  This change was made for revision D MCP23017 chips manufactured after June 2020. See the [MCP23017 datasheet](https://www.abelectronics.co.uk/docs/pdf/microchip-mcp23017.pdf) for more information.

## Methods
```
Connect() 
```
Connect to the Expander Pi  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected
**Parameters:** none  
**Returns:** boolean  

```
Dispose() 
```
Dispose of the active device  
**Parameters:** none  
**Returns:** null  

### ADC Methods

```
ADCReadVoltage(byte channel, byte mode) 
```
Read the voltage from the selected channel on the ADC.  
**Parameters:** channel (1 to 8)  
**Parameters:** mode (1 = Single Ended Input, 2 = Differential Input)  
**Returns:** voltage  

```
ADCReadRaw(byte channel, byte mode)
```
Read the raw value from the selected channel on the ADC.  
**Parameters:** channel (1 to 8)  
**Parameters:** mode (1 = Single Ended Input, 2 = Differential Input)  
**Returns:** voltage  

```
ADCSetRefVoltage(double voltage) 
```
Set the reference voltage for the analogue to digital converter.  
The Expander Pi contains an onboard 4.096V voltage reference.  
If you want to use an external reference between 0V and 5V, disconnect the jumper J1 and connect your reference voltage to the Vref pin.  
**Parameters:** voltage  
**Returns:** null  

### DAC Methods

```
DACSetVoltage(byte channel, double voltage, byte gain)
```
Set the voltage for the selected channel on the DAC.  
**Parameters:** channel (1 or 2)  
**Parameters:** voltage (Voltage will be between 0 and 2.047V when gain is 1, 0 and 4.096V when gain is 2)  
**Parameters:** gain (1 or 2)  
**Returns:** null  

```
DACSetRaw(byte channel, short value, byte gain)
```
Set the voltage for the selected channel on the DAC.  
Voltage will be between 0 and 2.047V when gain is 1, 0 and 4.096V when gain is 2  
**Parameters:** channel (1 or 2)  
**Parameters:** value (0 to 4095)  
**Parameters:** gain (1 or 2)  
**Returns:** null

### IO Methods
```
IOSetPinDirection(byte pin, bool direction)  
```
Sets the IO direction for an individual pin  
**Parameters:** pin - 1 to 16, direction - true = input, false = output  
**Returns:** null

```
IOSetPortDirection(byte port, byte direction)
```
Sets the IO direction for the specified IO port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, direction - true = input, false = output  
**Returns:** null

```
IOSetPinPullup(byte pin, bool value)
```
Set the internal 100K pull-up resistors for the selected IO pin  
**Parameters:** pin - 1 to 16, value: true = Enabled, false = Disabled  
**Returns:** null
```
IOSetPortPullups(byte port, byte value)
```
Set the internal 100K pull-up resistors for the selected IO port  
**Parameters:** 0 = pins 1 to 8, 1 = pins 9 to 16, value: true = Enabled, false = Disabled   
**Returns:** null

```
IOWritePin(byte pin, bool value)
```
Write to an individual pin 1 - 16  
**Parameters:** pin - 1 to 16, value - true = Enabled, false = Disabled
**Returns:** null
```
IOWritePort(byte port, byte value)
```
Write to all pins on the selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, value -  number between 0 and 255 or 0x00 and 0xFF  
**Returns:** null
```
IOReadPin(byte pin)
```
Read the value of an individual pin 1 - 16   
**Parameters:** pin: 1 to 16  
**Returns:** false = logic level low, true = logic level high
```
IOReadPort(byte port)
```
Read all pins on the selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** number between 0 and 255 or 0x00 and 0xFF
```
IOInvertPort(byte port, byte polarity)
```
Invert the polarity of the pins on a selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, polarity - 0 = same logic state of the input pin, 1 = inverted logic state of the input pin  
**Returns:** null

```
IOInvertPin(byte pin, bool polarity)
```
Invert the polarity of the selected pin  
**Parameters:** pin - 1 to 16, polarity - false = same logic state of the input pin, true = inverted logic state of the input pin
**Returns:** null
```
IOMirrorInterrupts(byte value)
```
Mirror Interrupts  
**Parameters:** value - 1 = The INT pins are internally connected, 0 = The INT pins are not connected. INTA is associated with PortA and INTB is associated with PortB  
**Returns:** null

```
IOSetInterruptPolarity(byte value)
```
This sets the polarity of the INT output pins  
**Parameters:** 1 = Active - high. 0 = Active - low.  
**Returns:** null  

```
IOSetInterruptType(byte port, byte value)
```
Sets the type of interrupt for each pin on the selected port  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: number between 0 and 255 or 0x00 and 0xFF.  1 = interrupt is fired when the pin matches the default value, 0 = the interrupt is fired on state change  
**Returns:** null
```
IOSetInterruptDefaults(byte port, byte value)
```
These bits set the compare value for pins configured for interrupt-on-change on the selected port.  
If the associated pin level is the opposite from the register bit, an interrupt occurs.    
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: compare value  
**Returns:** null
```
IOSetInterruptOnPort(byte port, byte value)
```
Enable interrupts for the pins on the selected port  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: number between 0 and 255 or 0x00 and 0xFF  
**Returns:** null

```
IOSetInterruptOnPin(byte pin, bool value)
```
Enable interrupts for the selected pin  
**Parameters:** pin - 1 to 16, value - true = interrupt enabled, false = interrupt disabled  
**Returns:** null

```
IOReadInterruptStatus(byte port)
```
Enable interrupts for the selected pin  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** status

```
IOReadInterruptCapture(byte port)
```
Read the value from the selected port at the time of the last interrupt trigger  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** status
```
IOResetInterrupts()
```
Set the interrupts A and B to 0  
**Parameters:** null  
**Returns:** null

### RTC Methods

```
RTCSetDate(DateTime date)
```
Set the date and time on the RTC   
**Parameters:** date as DateTime
**Returns:** null

```
RTCReadDate() 
```
Returns the date from the RTC in ISO 8601 format - YYYY-MM-DDTHH:MM:SS  
**Returns:** date as DateTime  

```
RTCEnableOutput() 
```
Enable the square-wave output on the SQW pin.  
**Returns:** null  

```
RTCDisableOutput()
```
Disable the square-wave output on the SQW pin.   
**Returns:** null

```
RTCSetFrequency(byte frequency)
```
Set the frequency for the square-wave output on the SQW pin.   
**Parameters:** frequency - options are: 1 = 1Hz, 2 = 4.096KHz, 3 = 8.192KHz, 4 = 32.768KHz   
**Returns:** null

## Usage:

To use the Expander Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the io class:
```
ABElectronics_Win10IOT_Libraries.IOPi expi = new ABElectronics_Win10IOT_Libraries.ExpanderPi();
```

Next we need to connect to the device and wait for the connection before setting the digital IO ports to be inputs
```
expi.Connect();

while (!expi.IsConnected)
{
}
expi.IOSetPortDirection(0, 0xFF);
expi.IOSetPortDirection(1, 0xFF);

```

You can now read the input status from pin 1 on the digital IO bus with:
```
bool value = bus1.IOReadPin(1);
```


# IOPi
This class contains methods for use with the IO Pi, IO Pi Plus and IO Pi Zero from  
https://www.abelectronics.co.uk/p/54/IO-Pi-Plus  
https://www.abelectronics.co.uk/p/71/IO-Pi-Zero  

**Note:** Microchip recommends that pin 8 (GPA7) and pin 16 (GPB7) are used as outputs only.  This change was made for revision D MCP23017 chips manufactured after June 2020. See the [MCP23017 datasheet](https://www.abelectronics.co.uk/docs/pdf/microchip-mcp23017.pdf) for more information.

## Methods:
```
Connect() 
```
Connect to the I2C device  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected  
**Parameters:** none  
**Returns:** boolean  

```
Dispose() 
```
Dispose of the active I2C device  
**Parameters:** none  
**Returns:** null  

```
SetPinDirection(byte pin, bool direction)
```
Sets the IO direction for an individual pin  
**Parameters:** pin - 1 to 16, direction - true = input, false = output  
**Returns:** null  

```
SetPortDirection(byte port, byte direction)
```
Sets the IO direction for the specified IO port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, direction - true = input, false = output  
**Returns:** null  

```
SetPinPullup(byte pin, bool value)
```
Set the internal 100K pull-up resistors for the selected IO pin  
**Parameters:** pin - 1 to 16, value: true = Enabled, false = Disabled  
**Returns:** null  
```
SetPortPullups(byte port, byte value)
```
Set the internal 100K pull-up resistors for the selected IO port  
**Parameters:** 0 = pins 1 to 8, 1 = pins 9 to 16, value: true = Enabled, false = Disabled  
**Returns:** null  

```
WritePin(byte pin, bool value)
```
Write to an individual pin 1 - 16  
**Parameters:** pin - 1 to 16, value - true = Enabled, false = Disabled  
**Returns:** null  
```
WritePort(byte port, byte value)
```
Write to all pins on the selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, value -  number between 0 and 255 or 0x00 and 0xFF  
**Returns:** null
```
ReadPin(byte pin)
```
Read the value of an individual pin 1 - 16   
**Parameters:** pin: 1 to 16  
**Returns:** false = logic level low, true = logic level high
```
ReadPort(byte port)
```
Read all pins on the selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** number between 0 and 255 or 0x00 and 0xFF
```
InvertPort(byte port, byte polarity)
```
Invert the polarity of the pins on a selected port  
**Parameters:** port - 0 = pins 1 to 8, port 1 = pins 9 to 16, polarity - 0 = same logic state of the input pin, 1 = inverted logic state of the input pin  
**Returns:** null

```
InvertPin(byte pin, bool polarity)
```
Invert the polarity of the selected pin  
**Parameters:** pin - 1 to 16, polarity - false = same logic state of the input pin, true = inverted logic state of the input pin
**Returns:** null
```
MirrorInterrupts(byte value)
```
Mirror Interrupts  
**Parameters:** value - 1 = The INT pins are internally connected, 0 = The INT pins are not connected. INTA is associated with PortA and INTB is associated with PortB  
**Returns:** null

```
SetInterruptPolarity(byte value)
```
This sets the polarity of the INT output pins  
**Parameters:** 1 = Active - high. 0 = Active - low.  
**Returns:** null  

```
SetInterruptType(byte port, byte value)
```
Sets the type of interrupt for each pin on the selected port  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: number between 0 and 255 or 0x00 and 0xFF. 1 = interrupt is fired when the pin matches the default value, 0 = the interrupt is fired on state change  
**Returns:** null
```
SetInterruptDefaults(byte port, byte value)
```
These bits set the compare value for pins configured for interrupt-on-change on the selected port.  
If the associated pin level is the opposite from the register bit, an interrupt occurs.    
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: compare value  
**Returns:** null
```
SetInterruptOnPort(byte port, byte value)
```
Enable interrupts for the pins on the selected port  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16, value: number between 0 and 255 or 0x00 and 0xFF  
**Returns:** null

```
SetInterruptOnPin(byte pin, bool value)
```
Enable interrupts for the selected pin  
**Parameters:** pin - 1 to 16, value - true = interrupt enabled, false = interrupt disabled  
**Returns:** null

```
ReadInterruptStatus(byte port)
```
Enable interrupts for the selected pin  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** status

```
ReadInterruptCapture(byte port)
```
Read the value from the selected port at the time of the last interrupt trigger  
**Parameters:** port 0 = pins 1 to 8, port 1 = pins 9 to 16  
**Returns:** status
```
ResetInterrupts()
```
Set the interrupts A and B to 0  
**Parameters:** null  
**Returns:** null
### Usage

To use the IO Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the io class:
```
ABElectronics_Win10IOT_Libraries.IOPi bus1 = new ABElectronics_Win10IOT_Libraries.IOPi(0x20);
```
The argument is the I2C addresses of the IO chip. The value shown are the default addresses of the IO board which are 0x20 and 0x21.

Next we need to connect to the device and wait for the connection before setting ports to be inputs
```
bus1.Connect();

while (!bus1.IsConnected)
{
}
bus1.SetPortDirection(0, 0xFF);
bus1.SetPortDirection(1, 0xFF);

```

You can now read the input status from channel 1 with:
```
bool value = bus1.ReadPin(1);
```

# RTCPi
This class contains methods for use with the RTC Pi, RTC Pi Plus and RTC Pi Zero from https://www.abelectronics.co.uk/p/52/RTC-Pi-Plus  
https://www.abelectronics.co.uk/p/70/RTC-Pi-Zero  

## Methods:
```
Connect() 
```
Connect to the I2C device  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected  
**Parameters:** none  
**Returns:** boolean  

```
Dispose() 
```
Dispose of the active I2C device  
**Parameters:** none  
**Returns:** null  

```
SetDate(DateTime date)
```
Set the date and time on the RTC  
**Parameters:** date as DateTime  
**Returns:** null  

```
ReadDate() 
```
Returns the date from the RTC in ISO 8601 format - YYYY-MM-DDTHH:MM:SS  
**Returns:** date as DateTime  


```
EnableOutput() 
```
Enable the square-wave output on the SQW pin.  
**Returns:** null  

```
DisableOutput()
```
Disable the square-wave output on the SQW pin.   
**Returns:** null  

```
SetFrequency(byte frequency)
```
Set the frequency for the square-wave output on the SQW pin.   
**Parameters:** frequency - options are: 1 = 1Hz, 2 = 4.096KHz, 3 = 8.192KHz, 4 = 32.768KHz  
**Returns:** null  

## Usage

To use the RTC Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the rtc class:
```
ABElectronics_Win10IOT_Libraries.RTCPi rtc = new ABElectronics_Win10IOT_Libraries.RTCPi();
```
Next we need to connect to the device and wait for the connection
```
rtc.Connect();

while (!rtc.IsConnected)
{
}

```
You can set the date and time from the RTC chip to be the 25th December 2015 at 6 AM with:
```
DateTime newdate = new DateTime(2015, 12, 25, 06, 00, 00);
rtc.SetDate(newdate);
```

You can read the date and time from the RTC chip with:
```
DateTime value = rtc.ReadDate();
```


# ServoPi
This class contains methods for use with the ServoPi and Servo PWM Pi Zero from  
https://www.abelectronics.co.uk/p/72/Servo-PWM-Pi-Zero

## Methods:
```
Connect() 
```
Connect to the I2C device  
**Parameters:** none  
**Returns:** null  

```
IsConnected() 
```
Check if the device is connected  
**Parameters:** none  
**Returns:** boolean  

```
Dispose() 
```
Dispose of the active I2C device  
**Parameters:** none  
**Returns:** null  

```
SetPwmFreq(freq) 
```
Set the PWM frequency  
**Parameters:** freq - required frequency  
**Returns:** null  

```
SetPwm(channel, on, off) 
```
Set the output on single channels  
**Parameters:** channel - 1 to 16, on - time period, off - time period  
**Returns:** null  


```
SetAllPwm( on, off) 
```
Set the output on all channels  
**Parameters:** on - time period, off - time period  
**Returns:** null  

```
byte OutputEnablePin { get; set; }
```
**Parameters:** Set the GPIO pin for the output enable function.  
**Returns:** null  
**Notes:** The default GPIO pin 4 is not supported in Windows 10 IOT so the OE pad will need to be connected to a different GPIO pin.  


```
OutputDisable()
```
Disable the output via OE pin  
**Parameters:** null  
**Returns:** null  

```
OutputEnable()
```
Enable the output via OE pin  
**Parameters:** null  
**Returns:** null  

## Usage

To use the ServoPi Pi library in your code you must first import the library dll:
```
using ABElectronics_Win10IOT_Libraries;
```
Next you must initialise the ServoPi class:
```
ABElectronics_Win10IOT_Libraries.ServoPi servo = new ABElectronics_Win10IOT_Libraries.ServoPi(0x40);
```
The argument is the I2C addresses of the Servo Pi chip.

Next we need to connect to the device and wait for the connection
```
servo.Connect();

while (!servo.IsConnected)
{
}

```
Set PWM frequency to 60 Hz and enable the output
```
servo.SetPWMFreqency(60);                       

```
**Optional**
You can set the enable pin to use the output enable functions and the enable and disable the output. 
The default GPIO pin 4 is not supported in Windows 10 IOT and so the OE pad will need to be connected to a different GPIO pin to use this functionality.

```
servo.OutputEnablePin(17); // set to GPIO pin 17
servo.OutputEnable();
```
```
Move the servo to a position and exit the application.
```
servo.SetPWM(1, 0, 300);

``` 
<file_sep>/ABElectronics_Win10IOT_Libraries/ABE_Helpers.cs
﻿using System;
using Windows.Devices.I2c;

namespace ABElectronics_Win10IOT_Libraries
{
	/// <summary>
	///     Helpers for the ABElectronics library.
	/// </summary>
	internal class ABE_Helpers
	{
		internal const string I2C_CONTROLLER_NAME = "I2C1";

		/// <summary>
		///     Updates the value of a single bit within a byte and returns the updated byte
		/// </summary>
		/// <param name="value">The byte to update</param>
		/// <param name="position">Position of the bit to change</param>
		/// <param name="bitstate">The new bit value</param>
		/// <returns>Updated byte</returns>
		internal byte UpdateByte(byte value, byte position, bool bitstate)
		{
			if (bitstate)
			{
				//left-shift 1, then bitwise OR
				return (byte) (value | (1 << position));
			}
			//left-shift 1, then take complement, then bitwise AND
			return (byte) (value & ~(1 << position));
		}

		/// <summary>
		///     Updates the value of a single bit within an int and returns the updated int
		/// </summary>
		/// <param name="value">The int to update</param>
		/// <param name="position">Position of the bit to change</param>
		/// <param name="bitstate">The new bit value</param>
		/// <returns>Updated int</returns>
		internal int UpdateInt(int value, byte position, bool bitstate)
		{
			if (bitstate)
			{
				//left-shift 1, then bitwise OR
				return value | (1 << position);
			}
			//left-shift 1, then take complement, then bitwise AND
			return value & ~(1 << position);
		}

		/// <summary>
		///     Checks the value of a single bit within a byte.
		/// </summary>
		/// <param name="value">The value to query</param>
		/// <param name="position">The bit position within the byte</param>
		/// <returns>boolean value of the asked bit</returns>
		internal bool CheckBit(byte value, byte position)
		{
			// internal method for reading the value of a single bit within a byte
			return (value & (1 << position)) != 0;
		}

		/// <summary>
		///     Checks the value of a single bit within an int.
		/// </summary>
		/// <param name="value">The value to query</param>
		/// <param name="position">The bit position within the byte</param>
		/// <returns>boolean value of the asked bit</returns>
		internal bool CheckIntBit(int value, byte position)
		{
			// internal method for reading the value of a single bit within a byte
			return (value & (1 << position)) != 0;
		}

		/// <summary>
		///     Writes a single byte to an I2C device.
		/// </summary>
		/// <param name="bus">I2C device</param>
		/// <param name="register">Address register</param>
		/// <param name="value">Value to write to the register</param>
		internal void WriteI2CByte(I2cDevice bus, byte register, byte value)
		{
			var writeBuffer = new[] { register, value};

			try
			{
				bus.Write(writeBuffer);
			}
			catch (Exception)
			{
				throw;
			}
		}

		/// <summary>
		///     Writes a single byte to an I2C device.
		/// </summary>
		/// <param name="bus">I2C device</param>
		/// <param name="value">Value to write to the register</param>
		internal void WriteI2CSingleByte(I2cDevice bus, byte value)
		{
			byte[] writeBuffer = {value};

			try
			{
				bus.Write(writeBuffer);
			}
			catch (Exception)
			{
				throw;
			}
		}

		/// <summary>
		///     Read a single byte from an I2C device.
		/// </summary>
		/// <param name="bus">I2C device</param>
		/// <param name="register">Address register to read from</param>
		/// <returns>Read value</returns>
		internal byte ReadI2CByte(I2cDevice bus, byte register)
		{
			try
			{
				var readBuffer = new[] { register};
				var returnValue = new byte[1];

				bus.WriteRead(readBuffer, returnValue);

				return returnValue[0];
			}
			catch (Exception)
			{
				throw;
			}
		}

		/// <summary>
		///     Read a single byte from an I2C device.
		/// </summary>
		/// <param name="bus">I2C device</param>
		/// <param name="register">Address register to read from</param>
		/// <param name="bytesToReturn">Number of bytes to return</param>
		/// <returns>Read block of bytes</returns>
		internal byte[] ReadI2CBlockData(I2cDevice bus, byte register, byte bytesToReturn)
		{
			try
			{
				var readBuffer = new[] { register };
				var returnValue = new byte[bytesToReturn];

				bus.WriteRead(readBuffer, returnValue);

				return returnValue;
			}
			catch (Exception)
			{
				throw;
			}
		}
	}
}<file_sep>/DemoApplication/ADCPi.xaml.cs
﻿using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using System.Threading;

namespace DemoApplication
{
    /// <summary>
    /// This demonstration shows how to read from the ADC Pi and update the bit rate and gain.
    /// </summary>
    public sealed partial class ADCPi : Page
    {
        // create an instance of the ADCPi class called adc
        ABElectronics_Win10IOT_Libraries.ADCPi adc = new ABElectronics_Win10IOT_Libraries.ADCPi();

        // set the time interval for sampling from the ADC and create a timer
        int TIME_INTERVAL_IN_MILLISECONDS = 10;
        Timer _timer;

        // this will be used to measure the sample rate from the ADC Pi
        DateTime startTime;

        // used to start and stop the sampling
        bool run = false;

        // temporary variables where the ADC values will be stored
        double channel1_value = 0;
        double channel2_value = 0;
        double channel3_value = 0;
        double channel4_value = 0;
        double channel5_value = 0;
        double channel6_value = 0;
        double channel7_value = 0;
        double channel8_value = 0;

        public ADCPi()
        {
            this.InitializeComponent();
        }

        private async void bt_Connect_Click(object sender, RoutedEventArgs e)
        {
            // when the connect button is clicked update the ADC i2c addresses with the values in the textboxes on the page
            try
            {
                adc.Address1 = Convert.ToByte(txt_Address1.Text.Replace("0x", ""), 16);
                adc.Address2 = Convert.ToByte(txt_Address2.Text.Replace("0x", ""), 16);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            // create a Connected event handler and connect to the ADC Pi.
            adc.Connected += Adc_Connected;
            await adc.Connect();
        }

        private void Adc_Connected(object sender, EventArgs e)
        {
            // The ADC Pi is connected

            // set the initial bit rate to 16
            adc.SetBitRate(16);
            radio_bitrate12.IsChecked = false;
            radio_bitrate14.IsChecked = false;
            radio_bitrate16.IsChecked = true;
            radio_bitrate18.IsChecked = false;

            // set the gain to 1
            adc.SetPGA(1);
            radio_Gain1.IsChecked = true;
            radio_Gain2.IsChecked = false;
            radio_Gain4.IsChecked = false;
            radio_Gain8.IsChecked = false;

            // set the startTime to be now and start the timer
            startTime = DateTime.Now;
            _timer = new Timer(ReadADC, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);

        }

        private async void ReadADC(object state)
        {
            // check to see if the run is true
            if (run)
            {
                // get the voltage values from all 8 ADC channels
                channel1_value = adc.ReadVoltage(1);
                channel2_value = adc.ReadVoltage(2);
                channel3_value = adc.ReadVoltage(3);
                channel4_value = adc.ReadVoltage(4);
                channel5_value = adc.ReadVoltage(5);
                channel6_value = adc.ReadVoltage(6);
                channel7_value = adc.ReadVoltage(7);
                channel8_value = adc.ReadVoltage(8);

                // use a dispatcher event to update the textboxes on the page
                await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    txt_Channel1.Text = channel1_value.ToString("F4");
                    txt_Channel2.Text = channel2_value.ToString("F4");
                    txt_Channel3.Text = channel3_value.ToString("F4");
                    txt_Channel4.Text = channel4_value.ToString("F4");
                    txt_Channel5.Text = channel5_value.ToString("F4");
                    txt_Channel6.Text = channel6_value.ToString("F4");
                    txt_Channel7.Text = channel7_value.ToString("F4");
                    txt_Channel8.Text = channel8_value.ToString("F4");
                });

                // calculate how long it has been since the last reading and use that to work out the sample rate
                TimeSpan duration = DateTime.Now.Subtract(startTime);
                startTime = DateTime.Now;
                WriteMessage((1000 / (duration.TotalMilliseconds / 8)).ToString("F2") + "sps");

                // reset the timer so it will run again after the preset period
                _timer.Change(TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            }
        }

        private void radio_bitrate_clicked(object sender, RoutedEventArgs e)
        {
            // find out which radio button was clicked and use that to update the bit rate for the ADC
            RadioButton cb = (RadioButton)sender;
            if (adc.IsConnected == true)
            {
                adc.SetBitRate(Convert.ToByte(cb.Content.ToString()));
            }
            else
            {
                WriteMessage("ADC not connected.");
            }
        }

        private void radio_gain_clicked(object sender, RoutedEventArgs e)
        {
            // find out which radio button was clicked and use that to update the gain for the ADC
            RadioButton cb = (RadioButton)sender;
            if (adc.IsConnected == true)
            {
                adc.SetPGA(Convert.ToByte(cb.Content.ToString()));
            }
            else
            {
                WriteMessage("ADC not connected.");
            }
        }

        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // go back to the main page
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }

        
        private async void WriteMessage(string message)
        {
            // WriteMessage is used to update the message box on the page
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                txt_Message.Text = message;
            });
        }

        private void bt_Start_Click(object sender, RoutedEventArgs e)
        {
            // set run to be true and call ReadADC to start the ADC reading
            run = true;
            ReadADC(null);
        }

        private void bt_Stop_Click(object sender, RoutedEventArgs e)
        {
            // set run to false to stop the ADC from reading
            run = false;
        }
    }
}
<file_sep>/ABElectronics_Win10IOT_Libraries/ADCDifferentialPi.cs
using System;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;
using Windows.Foundation.Metadata;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    ///     Class for controlling the ADC Differential Pi and Delta-Sigma Pi expansion board from AB Electronics UK
    /// </summary>
    public class ADCDifferentialPi : IDisposable
    {
        // create byte array and fill with initial values to define size

        private Byte[] __adcreading = {0, 0, 0, 0};
        private byte bitrate = 18; // current bit rate

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

        // internal variables

        private byte config1 = 0x9C; // PGAx1, 18 bit, continuous conversion, channel 1
        private byte config2 = 0x9C; // PGAx1, 18 bit, continuous-shot conversion, channel 1
        private byte conversionmode = 1; // Conversion Mode
        private byte currentchannel1; // channel variable for ADC 1
        private byte currentchannel2; // channel variable for ADC 2
        private readonly ABE_Helpers helper = new ABE_Helpers();

        private I2cDevice i2cbus1; // i2c bus for ADC chip 1
        private I2cDevice i2cbus2; // i2c bus for ADC chip 2
        private double lsb = 0.0000078125; // default LSB value for 18 bit
        private double pga = 0.5; // current PGA setting
        private bool signbit;

        /// <summary>
        ///     Create an instance of a Delta-Sigma Pi bus.
        /// </summary>
        /// <param name="i2caddress1">I2C address for the U1 (channels 1 - 4)</param>
        /// <param name="i2caddress2">I2C address for the U2 (channels 5 - 8)</param>
        public ADCDifferentialPi(byte i2caddress1 = 0x68, byte i2caddress2 = 0x69)
        {
            Address1 = i2caddress1;
            Address2 = i2caddress2;
            IsConnected = false;
        }

        /// <summary>
        ///     I2C address for the U1 (channels 1 - 4).
        /// </summary>
        public byte Address1 { get; set; }

        /// <summary>
        ///     I2C address for the U2 (channels 5 - 8).
        /// </summary>
        public byte Address2 { get; set; }

        /// <summary>
        ///     Shows if there is a connection with the ADC Pi.
        /// </summary>
        public bool IsConnected { get; private set; }

        /// <summary>
        ///     Open a connection with the Delta-Sigma Pi.
        /// </summary>
        public async Task Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.I2c.I2cDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            // Initialize both I2C busses
            try
            {
                var aqs = I2cDevice.GetDeviceSelector(ABE_Helpers.I2C_CONTROLLER_NAME); // Find the selector string for the I2C bus controller
                var dis = await DeviceInformation.FindAllAsync(aqs); // Find the I2C bus controller device with our selector string

                if (dis.Count == 0)
                {
                    return; // Controller not found
                }

                var settings1 = new I2cConnectionSettings(Address1) {BusSpeed = I2cBusSpeed.FastMode};
                var settings2 = new I2cConnectionSettings(Address2) {BusSpeed = I2cBusSpeed.FastMode};

                i2cbus1 = await I2cDevice.FromIdAsync(dis[0].Id, settings1); // Create an I2cDevice with our selected bus controller and I2C settings
                i2cbus2 = await I2cDevice.FromIdAsync(dis[0].Id, settings2); // Create an I2cDevice with our selected bus controller and I2C settings

                // check if the i2c busses are not null
                if (i2cbus1 != null && i2cbus2 != null)
                {
                    // set the initial bit rate and trigger a Connected event handler
                    IsConnected = true;
                    SetBitRate(bitrate);

                    // Fire the Connected event handler
                    Connected?.Invoke(this, EventArgs.Empty);
                }
            }
            catch(Exception ex)
            {
                IsConnected = false;
                throw new Exception("I2C Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;

        /// <summary>
        ///     Private method for updating the configuration to the selected <paramref name="channel" />.
        /// </summary>
        /// <param name="channel">ADC channel, 1 - 8</param>
        private void SetChannel(byte channel)
        {
            if (channel < 5 && channel != currentchannel1)
            {
                switch (channel)
                {
                    case 1:
                        config1 = helper.UpdateByte(config1, 5, false);
                        config1 = helper.UpdateByte(config1, 6, false);
                        currentchannel1 = 1;
                        break;
                    case 2:
                        config1 = helper.UpdateByte(config1, 5, true);
                        config1 = helper.UpdateByte(config1, 6, false);
                        currentchannel1 = 2;
                        break;
                    case 3:
                        config1 = helper.UpdateByte(config1, 5, false);
                        config1 = helper.UpdateByte(config1, 6, true);
                        currentchannel1 = 3;
                        break;
                    case 4:
                        config1 = helper.UpdateByte(config1, 5, true);
                        config1 = helper.UpdateByte(config1, 6, true);
                        currentchannel1 = 4;
                        break;
                }
            }
            else if (channel >= 5 && channel <= 8 && channel != currentchannel2)
            {
                switch (channel)
                {
                    case 5:
                        config2 = helper.UpdateByte(config2, 5, false);
                        config2 = helper.UpdateByte(config2, 6, false);
                        currentchannel2 = 5;
                        break;
                    case 6:
                        config2 = helper.UpdateByte(config2, 5, true);
                        config2 = helper.UpdateByte(config2, 6, false);
                        currentchannel2 = 6;
                        break;
                    case 7:
                        config2 = helper.UpdateByte(config2, 5, false);
                        config2 = helper.UpdateByte(config2, 6, true);
                        currentchannel2 = 7;
                        break;
                    case 8:
                        config2 = helper.UpdateByte(config2, 5, true);
                        config2 = helper.UpdateByte(config2, 6, true);
                        currentchannel2 = 8;
                        break;
                }
            }
        }

        /// <summary>
        ///     Returns the voltage from the selected ADC <paramref name="channel" />.
        /// </summary>
        /// <param name="channel">1 to 8</param>
        /// <returns>Read voltage</returns>
        public double ReadVoltage(byte channel)
        {
            var raw = ReadRaw(channel);

            double voltage = 0;

            if (signbit)
            {
                voltage = raw * (lsb / pga) - 2.048 / (pga * 2);
            }
            else
            {
                voltage = raw * (lsb / pga);
            }

            return voltage;
        }

        /// <summary>
        ///     Reads the raw value from the selected ADC <paramref name="channel" />.
        /// </summary>
        /// <param name="channel">1 to 8</param>
        /// <returns>raw integer value from ADC buffer</returns>
        public int ReadRaw(byte channel)
        {
            CheckConnected();

            byte h = 0;
            byte l = 0;
            byte m = 0;
            byte s = 0;
            byte config = 0;

            var t = 0;
            signbit = false;
            I2cDevice bus;

            SetChannel(channel);

            // get the configuration and i2c bus for the selected channel
            if (channel < 5)
            {
                config = config1;
                bus = i2cbus1;
            }
            else if (channel >= 5 && channel <= 8)
            {
                config = config2;
                bus = i2cbus2;
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(channel));
            }

            // set the configuration register for the selected channel

            // if the conversion mode is set to one-shot update the ready bit to 1
            if (conversionmode == 0)
            {
                config = helper.UpdateByte(config, 7, true);
                helper.WriteI2CByte(bus, config, 0x00);
                config = helper.UpdateByte(config, 7, false);
            }

            // keep reading the ADC data until the conversion result is ready
            var timeout = 10000; // number of reads before a timeout occurs
            var x = 0;
            do
            {
                if (bitrate == 18)
                {
                    __adcreading = helper.ReadI2CBlockData(bus, config, 4);
                    h = __adcreading[0];
                    m = __adcreading[1];
                    l = __adcreading[2];
                    s = __adcreading[3];
                }
                else
                {
                    __adcreading = helper.ReadI2CBlockData(bus, config, 3);
                    h = __adcreading[0];
                    m = __adcreading[1];
                    s = __adcreading[2];
                }

                // check bit 7 of s to see if the conversion result is ready
                if (!helper.CheckBit(s, 7))
                {
                    break;
                }

                if (x > timeout)
                {
                    // timeout occurred
                    throw new TimeoutException();
                }

                x++;
            } while (true);

            // extract the returned bytes and combine in the correct order
            switch (bitrate)
            {
                case 18:

                    t = ((h & 3) << 16) | (m << 8) | l;
                    signbit = helper.CheckIntBit(t, 17);
                    if (signbit)
                    {
                        t = helper.UpdateInt(t, 17, false);
                    }
                    break;
                case 16:
                    t = (h << 8) | m;
                    signbit = helper.CheckIntBit(t, 15);
                    if (signbit)
                    {
                        t = helper.UpdateInt(t, 15, false);
                    }
                    break;
                case 14:

                    t = ((h & 63) << 8) | m;
                    signbit = helper.CheckIntBit(t, 13);
                    if (signbit)
                    {
                        t = helper.UpdateInt(t, 13, false);
                    }
                    break;
                case 12:
                    t = ((h & 15) << 8) | m;
                    signbit = helper.CheckIntBit(t, 11);
                    if (signbit)
                    {
                        t = helper.UpdateInt(t, 11, false);
                    }
                    break;
                default:
                    throw new InvalidOperationException("Invalid Bitrate");
            }

            return t;
        }

        /// <summary>
        ///     Set the PGA (Programmable Gain Amplifier) <paramref name="gain"/>.
        /// </summary>
        /// <param name="gain">Set to 1, 2, 4 or 8</param>
        public void SetPGA(byte gain)
        {
            CheckConnected();

            switch (gain)
            {
                case 1:
                    config1 = helper.UpdateByte(config1, 0, false);
                    config1 = helper.UpdateByte(config1, 1, false);
                    config2 = helper.UpdateByte(config2, 0, false);
                    config2 = helper.UpdateByte(config2, 1, false);
                    pga = 0.5;
                    break;
                case 2:
                    config1 = helper.UpdateByte(config1, 0, true);
                    config1 = helper.UpdateByte(config1, 1, false);
                    config2 = helper.UpdateByte(config2, 0, true);
                    config2 = helper.UpdateByte(config2, 1, false);
                    pga = 1;
                    break;
                case 4:
                    config1 = helper.UpdateByte(config1, 0, false);
                    config1 = helper.UpdateByte(config1, 1, true);
                    config2 = helper.UpdateByte(config2, 0, false);
                    config2 = helper.UpdateByte(config2, 1, true);
                    pga = 2;
                    break;
                case 8:
                    config1 = helper.UpdateByte(config1, 0, true);
                    config1 = helper.UpdateByte(config1, 1, true);
                    config2 = helper.UpdateByte(config2, 0, true);
                    config2 = helper.UpdateByte(config2, 1, true);
                    pga = 4;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(gain));
            }

            // helper.WriteI2CSingleByte(i2cbus1, config1);
            // helper.WriteI2CSingleByte(i2cbus2, config2);
        }

        /// <summary>
        ///     Set the sample resolution (rate).
        /// </summary>
        /// <param name="rate">
        ///     12 = 12 bit(240SPS max),
        ///     14 = 14 bit(60SPS max),
        ///     16 = 16 bit(15SPS max),
        ///     18 = 18 bit(3.75SPS max)
        /// </param>
        public void SetBitRate(byte rate)
        {
            CheckConnected();

            switch (rate)
            {
                case 12:
                    config1 = helper.UpdateByte(config1, 2, false);
                    config1 = helper.UpdateByte(config1, 3, false);
                    config2 = helper.UpdateByte(config2, 2, false);
                    config2 = helper.UpdateByte(config2, 3, false);
                    bitrate = 12;
                    lsb = 0.0005;
                    break;
                case 14:
                    config1 = helper.UpdateByte(config1, 2, true);
                    config1 = helper.UpdateByte(config1, 3, false);
                    config2 = helper.UpdateByte(config2, 2, true);
                    config2 = helper.UpdateByte(config2, 3, false);
                    bitrate = 14;
                    lsb = 0.000125;
                    break;
                case 16:
                    config1 = helper.UpdateByte(config1, 2, false);
                    config1 = helper.UpdateByte(config1, 3, true);
                    config2 = helper.UpdateByte(config2, 2, false);
                    config2 = helper.UpdateByte(config2, 3, true);
                    bitrate = 16;
                    lsb = 0.00003125;
                    break;
                case 18:
                    config1 = helper.UpdateByte(config1, 2, true);
                    config1 = helper.UpdateByte(config1, 3, true);
                    config2 = helper.UpdateByte(config2, 2, true);
                    config2 = helper.UpdateByte(config2, 3, true);
                    bitrate = 18;
                    lsb = 0.0000078125;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(rate));
            }

            // helper.WriteI2CSingleByte(i2cbus1, config1);
            // helper.WriteI2CSingleByte(i2cbus2, config2);
        }

        /// <summary>
        ///     Set the conversion <paramref name="mode" /> for ADC.
        /// </summary>
        /// <param name="mode">0 = One shot conversion mode, 1 = Continuous conversion mode</param>
        private void SetConversionMode(bool mode)
        {
            if (mode)
            {
                config1 = helper.UpdateByte(config1, 4, true);
                config2 = helper.UpdateByte(config2, 4, true);
                conversionmode = 1;
            }
            else
            {
                config1 = helper.UpdateByte(config1, 4, false);
                config2 = helper.UpdateByte(config2, 4, false);
                conversionmode = 0;
            }
        }

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }

        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                i2cbus1?.Dispose();
                i2cbus1 = null;

                i2cbus2?.Dispose();
                i2cbus2 = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }
    }
}<file_sep>/DemoApplication/ServoPi.xaml.cs
﻿using System;
using System.Diagnostics;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;

namespace DemoApplication
{
    /// <summary>
    /// This demonstration shows how to use the PWM outputs on the Servo Pi from AB Electronics UK
    /// </summary>
    public sealed partial class ServoPi : Page
    {

        ABElectronics_Win10IOT_Libraries.ServoPi servo = new ABElectronics_Win10IOT_Libraries.ServoPi();        

        public ServoPi()
        {
            this.InitializeComponent();
        }

        private async void bt_Connect_Click(object sender, RoutedEventArgs e)
        {
            // check if the servo pi is already connected and if the i2c address textbox contains a value
            if ((!servo.IsConnected) && (txt_Address.Text.Length > 0))
            {
                    try
                    {
                        // set the i2c address from the textbox value
                        servo.Address = Convert.ToByte(txt_Address.Text.Replace("0x", ""), 16);

                        // create a Connected event listener and connect to the servo pi
                        servo.Connected += Servo_Connected; ;
                        await servo.Connect();
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
             }

        }

        private void Servo_Connected(object sender, EventArgs e)
        {
            // on connection get the value from the frequency slider and set the PWM frequency on the Servo Pi
            int frequency = Convert.ToInt32(slider_Frequency.Value);
            servo.SetPWMFreqency(frequency);
            WriteMessage("Connected");
        }

        private void FrequencySliderChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (servo.IsConnected)
            {
                // get the value from the frequency slider and set the PWM frequency on the Servo Pi
                int frequency = Convert.ToInt32(slider_Frequency.Value);
                servo.SetPWMFreqency(frequency);
            }
        }

       

        private void ChannelSliderChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            
            if (servo.IsConnected)
            {
                // Find out which slider was changed and use the slider value to update the PWM value on the Servo Pi

                Slider slider = (Slider)sender;
                byte channel = Convert.ToByte(slider.Name.ToString().Replace("slider_Channel", ""));
                short highvalue = 0;
                short lowvalue = Convert.ToInt16(slider.Value);
                Debug.WriteLine(highvalue.ToString() + " " + lowvalue.ToString());
                servo.SetPWM(channel, highvalue, lowvalue);
            }
        }

        private void cbServoControl_Click(object sender, RoutedEventArgs e)
        {
            // create an array containing all of the channel sliders
            Slider[] sliders = { slider_Channel1, slider_Channel2, slider_Channel3, slider_Channel4, slider_Channel5, slider_Channel6, slider_Channel7, slider_Channel8, slider_Channel9, slider_Channel10, slider_Channel11, slider_Channel12, slider_Channel13, slider_Channel14, slider_Channel15, slider_Channel16 };

            // check to see if the checkbox is checked
            if (cbServoControl.IsChecked == true)
            {
                // set the frequency to 60Hz and the slider limits to be 150 to 700
                // these values should allow the Servo Pi to control most RC model servos.
                slider_Frequency.Value = 60;
                servo.SetPWMFreqency(60);

                // loop through all of the sliders setting their value, minimum and maximum
                foreach (Slider slider in sliders)
                {
                    slider.Value = 425;
                    slider.Minimum = 150;
                    slider.Maximum = 700;
                }
                             

            }
            else
            {
                // reset the sliders to the default limits
                foreach (Slider slider in sliders)
                {
                    slider.Value = 0;
                    slider.Minimum = 0;
                    slider.Maximum = 4096;
                }
            }

        }

        private async void WriteMessage(string message)
        {
            // used to update the message textbox on the page
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                txt_Message.Text = message;
            });
        }

        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // dispose of the servo pi and go back to the main page
            try
            {
                servo.Dispose();
            }
            catch { }
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }

        
    }
}
<file_sep>/DemoApplication/IOPi.xaml.cs
﻿using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using System.Threading;


namespace DemoApplication
{
    /// <summary>
    /// This demonstration shows how to use the IO Pi class to write to and read from and IO Pi or IO Pi Plus
    /// </summary>
    public sealed partial class IOPi : Page
    {
        // The IO Pi contains two MCP23017 chips so we need to create a separate instance of the IOPi class for each chip and call the bus1 and bus2
        public ABElectronics_Win10IOT_Libraries.IOPi bus1 = new ABElectronics_Win10IOT_Libraries.IOPi(0x20);
        public ABElectronics_Win10IOT_Libraries.IOPi bus2 = new ABElectronics_Win10IOT_Libraries.IOPi(0x21);

        // create two timers for reading from each IO Pi bus
        int TIME_INTERVAL_IN_MILLISECONDS = 200;
        Timer _timer1;
        Timer _timer2;

        // used to set the bus direction.  true = read, false = write.
        bool Bus1_Direction = true;
        bool Bus2_Direction = true;

        public IOPi()
        {
            this.InitializeComponent();
            // initialise the timers with the preset period
            _timer1 = new Timer(Timer1_Tick, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            _timer2 = new Timer(Timer2_Tick, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);

        }

        private async void bt_Bus1_Connect_Click(object sender, RoutedEventArgs e)
        {
            // check to see if there is an address in the textbox for bus 1 and if so connect to the IO Pi
            if (txt_Bus1_Address.Text.Length > 0)
            {
                try {
                    // get the i2c address from the textbox for bus 1
                    bus1.Address = Convert.ToByte(txt_Bus1_Address.Text.Replace("0x",""), 16);
                    
                    // create an event handler for the Connected event and connect to bus 1
                    bus1.Connected += Bus1_Connected;
                    await bus1.Connect();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }


        private void Bus1_Connected(object sender, EventArgs e)
        {
            // bus 1 is connected so update the message box, read from the bus and start the timer
            WriteMessage("Bus 1 Connected");
            ReadBus1();
            _timer1.Change(TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
        }

        private async void bt_Bus2_Connect_Click(object sender, RoutedEventArgs e)
        {
            // check to see if there is an address in the textbox for bus 2 and if so connect to the IO Pi
            if (txt_Bus2_Address.Text.Length > 0)
            {
                try
                {
                    // get the i2c address from the textbox for bus 2
                    bus2.Address = Convert.ToByte(txt_Bus2_Address.Text.Replace("0x", ""), 16);

                    // create an event handler for the Connected event and connect to bus 2
                    bus2.Connected += Bus2_Connected;
                    await bus2.Connect();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        }

        private void Bus2_Connected(object sender, EventArgs e)
        {
            // bus 2 is connected so update the message box, read from the bus and start the timer
            WriteMessage("Bus 2 Connected");
            ReadBus2();
            _timer2.Change(TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
        }

        private void Timer1_Tick(Object state)
        {
            // on timer tick check if the bus is connected and read from the bus before resetting the timer
            if (bus1.IsConnected)
            {
                ReadBus1();
                _timer1.Change(TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            }
        }

        private void Timer2_Tick(Object state)
        {
            // on timer 2 tick check if the bus is connected and read from the bus before resetting the timer
            if (bus2.IsConnected)
            {
                ReadBus2();
                _timer2.Change(TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            }
        }

        private async void ReadBus1()
        {
            // check that the bus is connected
            if (bus1.IsConnected)
            {
                try
                {
                    // invoke the dispatcher to update the checkboxes for bus 1 with the values read from each pin
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
                        Bus1_Channel_01_checkBox.IsChecked = bus1.ReadPin(1);
                        Bus1_Channel_02_checkBox.IsChecked = bus1.ReadPin(2);
                        Bus1_Channel_03_checkBox.IsChecked = bus1.ReadPin(3);
                        Bus1_Channel_04_checkBox.IsChecked = bus1.ReadPin(4);
                        Bus1_Channel_05_checkBox.IsChecked = bus1.ReadPin(5);
                        Bus1_Channel_06_checkBox.IsChecked = bus1.ReadPin(6);
                        Bus1_Channel_07_checkBox.IsChecked = bus1.ReadPin(7);
                        Bus1_Channel_08_checkBox.IsChecked = bus1.ReadPin(8);
                        Bus1_Channel_09_checkBox.IsChecked = bus1.ReadPin(9);
                        Bus1_Channel_10_checkBox.IsChecked = bus1.ReadPin(10);
                        Bus1_Channel_11_checkBox.IsChecked = bus1.ReadPin(11);
                        Bus1_Channel_12_checkBox.IsChecked = bus1.ReadPin(12);
                        Bus1_Channel_13_checkBox.IsChecked = bus1.ReadPin(13);
                        Bus1_Channel_14_checkBox.IsChecked = bus1.ReadPin(14);
                        Bus1_Channel_15_checkBox.IsChecked = bus1.ReadPin(15);
                        Bus1_Channel_16_checkBox.IsChecked = bus1.ReadPin(16);
                    }
                    );

                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        private async void ReadBus2()
        {
            // check that the bus is connected
            if (bus2.IsConnected)
            {
                try
                {
                    // invoke the dispatcher to update the checkboxes for bus 1 with the values read from each pin
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => {
                        Bus2_Channel_01_checkBox.IsChecked = bus2.ReadPin(1);
                        Bus2_Channel_02_checkBox.IsChecked = bus2.ReadPin(2);
                        Bus2_Channel_03_checkBox.IsChecked = bus2.ReadPin(3);
                        Bus2_Channel_04_checkBox.IsChecked = bus2.ReadPin(4);
                        Bus2_Channel_05_checkBox.IsChecked = bus2.ReadPin(5);
                        Bus2_Channel_06_checkBox.IsChecked = bus2.ReadPin(6);
                        Bus2_Channel_07_checkBox.IsChecked = bus2.ReadPin(7);
                        Bus2_Channel_08_checkBox.IsChecked = bus2.ReadPin(8);
                        Bus2_Channel_09_checkBox.IsChecked = bus2.ReadPin(9);
                        Bus2_Channel_10_checkBox.IsChecked = bus2.ReadPin(10);
                        Bus2_Channel_11_checkBox.IsChecked = bus2.ReadPin(11);
                        Bus2_Channel_12_checkBox.IsChecked = bus2.ReadPin(12);
                        Bus2_Channel_13_checkBox.IsChecked = bus2.ReadPin(13);
                        Bus2_Channel_14_checkBox.IsChecked = bus2.ReadPin(14);
                        Bus2_Channel_15_checkBox.IsChecked = bus2.ReadPin(15);
                        Bus2_Channel_16_checkBox.IsChecked = bus2.ReadPin(16);
                    }
                    );

                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }
               

        private void Bus1_SetDirection(object sender, RoutedEventArgs e)
        {
            // read the values from the direction radio buttons and update the bus 1 ports using the SetPortDirection method
            if (radio_Bus1_Read.IsChecked == true)
            {
                if (bus1.IsConnected)
                {
                    bus1.SetPortDirection(0, 0xFF);
                    bus1.SetPortDirection(1, 0xFF);
                    Bus1_Direction = true;
                    
                    WriteMessage("Bus 1 Reading");
                }
                else
                {
                    radio_Bus1_Read.IsChecked = false;
                    WriteMessage("Bus 1 not connected");
                }
            }
            if (radio_Bus1_Write.IsChecked == true)
            {
                if (bus1.IsConnected)
                {
                    bus1.SetPortDirection(0, 0x00);
                    bus1.SetPortDirection(1, 0x00);
                    Bus1_Direction = false;

                    WriteMessage("Bus 1 Writing");
                }
                else
                {
                    radio_Bus1_Write.IsChecked = false;
                    WriteMessage("Bus 1 not connected");
                }
            }

        }

        private void Bus2_SetDirection(object sender, RoutedEventArgs e)
        {
            // read the values from the direction radio buttons and update the bus 2 ports using the SetPortDirection method
            if (radio_Bus2_Read.IsChecked == true)
            {
                if (bus2.IsConnected)
                {
                    bus2.SetPortDirection(0, 0xFF);
                    bus2.SetPortDirection(1, 0xFF);
                    Bus2_Direction = true;                    

                    WriteMessage("Bus 2 Reading");
                }
                else
                {
                    radio_Bus2_Read.IsChecked = false;
                    WriteMessage("Bus 2 not connected");
                }
            }
            if (radio_Bus2_Write.IsChecked == true)
            {
                if (bus2.IsConnected)
                {
                    bus2.SetPortDirection(0, 0x00);
                    bus2.SetPortDirection(1, 0x00);
                    Bus2_Direction = false;

                    WriteMessage("Bus 2 Writing");
                }
                else
                {
                    radio_Bus2_Write.IsChecked = false;
                    WriteMessage("Bus 2 not connected");
                }
            }
        }


        private void Bus1_EnablePullups(object sender, RoutedEventArgs e)
        {
            // get the value from the pull-ups checkbox and set the port pull-ups to the required state using the SetPortPullups method
            CheckBox cb = (CheckBox)sender;
            if (bus1.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    bus1.SetPortPullups(0, 0xFF);
                    bus1.SetPortPullups(1, 0xFF);
                }
                else
                {
                    bus1.SetPortPullups(0, 0x00);
                    bus1.SetPortPullups(1, 0x00);
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 1 not connected");
            }
        }

        private void Bus2_EnablePullups(object sender, RoutedEventArgs e)
        {
            // get the value from the pull-ups checkbox and set the port pull-ups to the required state using the SetPortPullups method
            CheckBox cb = (CheckBox)sender;
            if (bus2.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    bus2.SetPortPullups(0, 0xFF);
                    bus2.SetPortPullups(1, 0xFF);
                }
                else
                {
                    bus2.SetPortPullups(0, 0x00);
                    bus2.SetPortPullups(1, 0x00);
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected");
            }
        }

        

        private void Bus1_InvertPort(object sender, RoutedEventArgs e)
        {
            // get the value from the invert port checkbox and set the port to the required state using the InvertPort method
            CheckBox cb = (CheckBox)sender;
            if (bus1.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    bus1.InvertPort(0, 0xFF);
                    bus1.InvertPort(1, 0xFF);

                    WriteMessage("Bus 2 Inverted");
                }
                else
                {
                    bus1.InvertPort(0, 0x00);
                    bus1.InvertPort(1, 0x00);

                    WriteMessage("Bus 1 not inverted");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 1 not connected");
            }
        }

        private void Bus2_InvertPort(object sender, RoutedEventArgs e)
        {
            // get the value from the invert port checkbox and set the port to the required state using the InvertPort method
            CheckBox cb = (CheckBox)sender;
            if (bus2.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    bus2.InvertPort(0, 0xFF);
                    bus2.InvertPort(1, 0xFF);

                    WriteMessage("Bus 2 Inverted");
                }
                else
                {
                    bus2.InvertPort(0, 0x00);
                    bus2.InvertPort(1, 0x00);

                    WriteMessage("Bus 2 not inverted");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected");
            }
        }
        private void Bus1_EnablePort0(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (bus1.IsConnected == true)
            {
                if (Bus1_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        bus1.WritePort(0, 0xFF);
                    }
                    else
                    {
                        bus1.WritePort(0, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 1 not connected.");
            }
        }

        private void Bus1_EnablePort1(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (bus1.IsConnected == true)
            {
                if (Bus1_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        bus1.WritePort(1, 0xFF);
                    }
                    else
                    {
                        bus1.WritePort(1, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 1 not connected.");
            }
        }

        private void Bus2_EnablePort0(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (bus2.IsConnected == true)
            {
                if (Bus2_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        bus2.WritePort(0, 0xFF);
                    }
                    else
                    {
                        bus2.WritePort(0, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected.");
            }
        }

        private void Bus2_EnablePort1(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (bus2.IsConnected == true)
            {
                if (Bus2_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        bus2.WritePort(1, 0xFF);
                    }
                    else
                    {
                        bus2.WritePort(1, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected.");
            }
        }

        private void Bus1_PinEnable(object sender, RoutedEventArgs e)
        {
            // check which pin checkbox was clicked and update the value of that pin to the required state
            CheckBox cb = (CheckBox)sender;
            if (bus1.IsConnected == true)
            {
                if (Bus1_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        bus1.WritePin(Convert.ToByte(cb.Content.ToString()), true);
                    }
                    else
                    {
                        bus1.WritePin(Convert.ToByte(cb.Content.ToString()), false);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a pin state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected.");
            }
        }

        private void Bus2_PinEnable(object sender, RoutedEventArgs e)
        {
            // check which pin checkbox was clicked and update the value of that pin to the required state
            CheckBox cb = (CheckBox)sender;
            if (bus2.IsConnected == true) {
                if (Bus2_Direction == false) {            
                    if (cb.IsChecked == true)
                    {
                        bus2.WritePin(Convert.ToByte(cb.Content.ToString()), true);               
                    }
                    else
                    {
                        bus2.WritePin(Convert.ToByte(cb.Content.ToString()), false);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a pin state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("Bus 2 not connected.");
            }
        }


        private async void WriteMessage(string message)
        {
            // this method updates the Message textbox on the page
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                txt_Message.Text = message;
            });
        }

        
        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // go back to the main page
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }

    }
}
<file_sep>/ABElectronics_Win10IOT_Libraries/IOPi.cs
using System;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;
using Windows.Foundation.Metadata;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    ///     Class for controlling the IO Pi and IO Pi Plus expansion boards from AB Electronics UK
    ///     Based on the MCP23017 IO expander IC from Microchip.
    /// </summary>
    public class IOPi : IDisposable
    {
        // Define registers values from datasheet

        /// <summary>
        ///     IO direction A - 1= input 0 = output
        /// </summary>
        private const byte IODIRA = 0x00;

        /// <summary>
        ///     IO direction B - 1= input 0 = output
        /// </summary>
        private const byte IODIRB = 0x01;

        /// <summary>
        ///     Input polarity A - If a bit is set, the corresponding GPIO register bit will reflect the inverted value on the pin.
        /// </summary>
        private const byte IPOLA = 0x02;

        /// <summary>
        ///     Input polarity B - If a bit is set, the corresponding GPIO register bit will reflect the inverted value on the pin.
        /// </summary>
        private const byte IPOLB = 0x03;

        /// <summary>
        ///     The GPINTEN register controls the interrupt-on-change feature for each pin on port A.
        /// </summary>
        private const byte GPINTENA = 0x04;

        /// <summary>
        ///     The GPINTEN register controls the interrupt-on-change feature for each pin on port B.
        /// </summary>
        private const byte GPINTENB = 0x05;

        /// <summary>
        ///     Default value for port A - These bits set the compare value for pins configured for interrupt-on-change. If the
        ///     associated pin level is the opposite from the register bit, an interrupt occurs.
        /// </summary>
        private const byte DEFVALA = 0x06;

        /// <summary>
        ///     Default value for port B - These bits set the compare value for pins configured for interrupt-on-change. If the
        ///     associated pin level is the opposite from the register bit, an interrupt occurs.
        /// </summary>
        private const byte DEFVALB = 0x07;

        /// <summary>
        ///     Interrupt control register for port A.  If 1 interrupt is fired when the pin matches the default value, if 0 the
        ///     interrupt is fired on state change.
        /// </summary>
        private const byte INTCONA = 0x08;

        /// <summary>
        ///     Interrupt control register for port B.  If 1 interrupt is fired when the pin matches the default value, if 0 the
        ///     interrupt is fired on state change.
        /// </summary>
        private const byte INTCONB = 0x09;

        /// <summary>
        ///     See datasheet for configuration register
        /// </summary>
        private const byte IOCON = 0x0A;

        /// <summary>
        ///     pull-up resistors for port A
        /// </summary>
        private const byte GPPUA = 0x0C;

        /// <summary>
        ///     pull-up resistors for port B
        /// </summary>
        private const byte GPPUB = 0x0D;

        /// <summary>
        ///     The INTFA register reflects the interrupt condition on the port A pins of any pin that is enabled for interrupts. A
        ///     set bit indicates that the associated pin caused the interrupt.
        /// </summary>
        private const byte INTFA = 0x0E;

        /// <summary>
        ///     The INTFB register reflects the interrupt condition on the port B pins of any pin that is enabled for interrupts. A
        ///     set bit indicates that the associated pin caused the interrupt.
        /// </summary>
        private const byte INTFB = 0x0F;

        /// <summary>
        ///     The INTCAP register captures the GPIO port A value at the time the interrupt occurred.
        /// </summary>
        private const byte INTCAPA = 0x10;

        /// <summary>
        ///     The INTCAP register captures the GPIO port B value at the time the interrupt occurred.
        /// </summary>
        private const byte INTCAPB = 0x11;

        /// <summary>
        ///     Data port A.
        /// </summary>
        private const byte GPIOA = 0x12;

        /// <summary>
        ///     Data port B.
        /// </summary>
        private const byte GPIOB = 0x13;

        /// <summary>
        ///     Output latches A.
        /// </summary>
        private const byte OLATA = 0x14;

        /// <summary>
        ///     Output latches B
        /// </summary>
        private const byte OLATB = 0x15;

        private readonly ABE_Helpers helper = new ABE_Helpers();


        private byte config = 0x22; // initial configuration - see IOCON page in the MCP23017 datasheet for more information.

        private I2cDevice i2cbus; // create an instance of the i2c bus
        private byte intA; // interrupt control for port a
        private byte intB; // interrupt control for port a

        // variables
        private byte port_a_dir; // port a direction
        private byte port_b_dir; // port b direction
        private byte porta_polarity; // input polarity for port a
        private byte porta_pullup; // port a pull-up resistors
        private byte portaval; // port a value
        private byte portb_polarity; // input polarity for port b
        private byte portb_pullup; // port a pull-up resistors
        private byte portbval; // port b value

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

        /// <summary>
        ///     Create an instance of an IOPi bus.
        /// </summary>
        /// <param name="i2caddress">I2C Address of IO Pi bus</param>
        public IOPi(byte i2caddress)
        {
            Address = i2caddress;
            IsConnected = false;
        }

        /// <summary>
        ///     I2C address for the IO Pi bus
        /// </summary>
        public byte Address { get; set; }

        /// <summary>
        ///     Shows if there is a connection with the IO Pi
        /// </summary>
        public bool IsConnected { get; private set; }

        /// <summary>
        ///     Open a connection with the IO Pi.
        /// </summary>
        public async Task Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.I2c.I2cDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            /* Initialize the I2C bus */
            try
            {
                var aqs = I2cDevice.GetDeviceSelector(ABE_Helpers.I2C_CONTROLLER_NAME); // Find the selector string for the I2C bus controller
                var dis = await DeviceInformation.FindAllAsync(aqs); // Find the I2C bus controller device with our selector string

                if (dis.Count == 0)
                {
                    return; // Controller not found
                }

                var settings = new I2cConnectionSettings(Address) {BusSpeed = I2cBusSpeed.FastMode};

                i2cbus = await I2cDevice.FromIdAsync(dis[0].Id, settings); // Create an I2cDevice with our selected bus controller and I2C settings
                if (i2cbus != null)
                {
                    // Set IsConnected to true and fire the Connected event handler
                    IsConnected = true;

                    // i2c bus is connected so set up the initial configuration for the IO Pi
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    portaval = helper.ReadI2CByte(i2cbus, GPIOA);
                    portbval = helper.ReadI2CByte(i2cbus, GPIOB);
                    helper.WriteI2CByte(i2cbus, IODIRA, 0xFF);
                    helper.WriteI2CByte(i2cbus, IODIRB, 0xFF);
                    SetPortPullups(0, 0x00);
                    SetPortPullups(1, 0x00);
                    InvertPort(0, 0x00);
                    InvertPort(1, 0x00);

                    

                    // Fire the Connected event handler
                    Connected?.Invoke(this, EventArgs.Empty);
                }
            }
            catch (Exception ex)
            {
                IsConnected = false;
                throw new Exception("I2C Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;

        /// <summary>
        ///     Set IO <paramref name="direction" /> for an individual pin.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="direction">true = input, false = output</param>
        public void SetPinDirection(byte pin, bool direction)
        {
            CheckConnected();

            pin = (byte) (pin - 1);

            if (pin < 8)
            {
                port_a_dir = helper.UpdateByte(port_a_dir, pin, direction);
                helper.WriteI2CByte(i2cbus, IODIRA, port_a_dir);
            }
            else if (pin >= 8 && pin < 16)
            {
                port_b_dir = helper.UpdateByte(port_b_dir, (byte) (pin - 8), direction);
                helper.WriteI2CByte(i2cbus, IODIRB, port_b_dir);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     get the direction of an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <returns>0 = logic level low, 1 = logic level high</returns>
        public bool GetPinDirection(byte pin)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                port_a_dir = helper.ReadI2CByte(i2cbus, IODIRA);
                return helper.CheckBit(port_a_dir, pin);
            }
            if (pin >= 8 && pin < 16)
            {
                port_b_dir = helper.ReadI2CByte(i2cbus, IODIRB);
                return helper.CheckBit(port_b_dir, (byte)(pin - 8));
            }
            throw new ArgumentOutOfRangeException(nameof(pin));
        }

        /// <summary>
        ///     Set the <paramref name="direction"/> for an IO <paramref name="port"/>.
        ///     You can control the direction of all 8 pins on a port by sending a single byte value.
        ///     Each bit in the byte represents one pin so for example 0x0A would set pins 2 and 4 to
        ///     inputs and all other pins to outputs.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="direction">Direction for all pins on the port.  1 = input, 0 = output</param>
        public void SetPortDirection(byte port, byte direction)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, IODIRA, direction);
                    port_a_dir = direction;
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, IODIRB, direction);
                    port_b_dir = direction;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }



        /// <summary>
        ///     Set the internal 100K pull-up resistors for an individual pin.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="value">true = enabled, false = disabled</param>
        public void SetPinPullup(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte) (pin - 1);

            if (pin < 8)
            {
                porta_pullup = helper.UpdateByte(porta_pullup, pin, value);
                helper.WriteI2CByte(i2cbus, GPPUA, porta_pullup);
            }
            else if (pin >= 8 && pin < 16)
            {
                portb_pullup = helper.UpdateByte(portb_pullup, (byte) (pin - 8), value);
                helper.WriteI2CByte(i2cbus, GPPUB, portb_pullup);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     get the pull-up status of an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <returns>0 = logic level low, 1 = logic level high</returns>
        public bool GetPinPullUp(byte pin)
        {
            CheckConnected();

            pin = (byte)(pin - 1);
            if (pin < 8)
            {
                porta_pullup = helper.ReadI2CByte(i2cbus, GPPUA);
                return helper.CheckBit(porta_pullup, pin);
            }
            if (pin >= 8 && pin < 16)
            {
                portb_pullup = helper.ReadI2CByte(i2cbus, GPPUB);
                return helper.CheckBit(portb_pullup, (byte)(pin - 8));
            }
            throw new ArgumentOutOfRangeException(nameof(pin));
        }

        /// <summary>
        ///     set the internal 100K pull-up resistors for the selected IO port.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void SetPortPullups(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    porta_pullup = value;
                    helper.WriteI2CByte(i2cbus, GPPUA, value);
                    break;
                case 1:
                    portb_pullup = value;
                    helper.WriteI2CByte(i2cbus, GPPUB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Write to an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <param name="value">0 = logic low, 1 = logic high</param>
        public void WritePin(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte) (pin - 1);
            if (pin < 8)
            {
                portaval = helper.UpdateByte(portaval, pin, value);
                helper.WriteI2CByte(i2cbus, GPIOA, portaval);
            }
            else if (pin >= 8 && pin < 16)
            {
                portbval = helper.UpdateByte(portbval, (byte) (pin - 8), value);
                helper.WriteI2CByte(i2cbus, GPIOB, portbval);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Write to all pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void WritePort(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, GPIOA, value);
                    portaval = value;
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, GPIOB, value);
                    portbval = value;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     read the value of an individual <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 - 16</param>
        /// <returns>0 = logic level low, 1 = logic level high</returns>
        public bool ReadPin(byte pin)
        {
            CheckConnected();

            pin = (byte) (pin - 1);
            if (pin < 8)
            {
                portaval = helper.ReadI2CByte(i2cbus, GPIOA);
                return helper.CheckBit(portaval, pin);
            }
            if (pin >= 8 && pin < 16)
            {
                portbval = helper.ReadI2CByte(i2cbus, GPIOB);
                return helper.CheckBit(portbval, (byte) (pin - 8));
            }
            throw new ArgumentOutOfRangeException(nameof(pin));
        }

        /// <summary>
        ///     Read all pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <returns>returns number between 0 and 255 or 0x00 and 0xFF</returns>
        public byte ReadPort(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    portaval = helper.ReadI2CByte(i2cbus, GPIOA);
                    return portaval;
                case 1:
                    portbval = helper.ReadI2CByte(i2cbus, GPIOB);
                    return portbval;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Invert the polarity of the pins on a selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="polarity">0x00 - 0xFF (0 = same logic state of the input pin, 1 = inverted logic state of the input pin)</param>
        public void InvertPort(byte port, byte polarity)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, IPOLA, polarity);
                    porta_polarity = polarity;
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, IPOLB, polarity);
                    portb_polarity = polarity;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Invert the <paramref name="polarity" /> of the selected <paramref name="pin" />.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="polarity">False = same logic state of the input pin, True = inverted logic state of the input pin</param>
        public void InvertPin(byte pin, bool polarity)
        {
            CheckConnected();

            pin = (byte) (pin - 1);
            if (pin < 8)
            {
                porta_polarity = helper.UpdateByte(porta_polarity, pin, polarity);
                helper.WriteI2CByte(i2cbus, IPOLA, porta_polarity);
            }
            else if (pin >= 8 && pin < 16)
            {
                portb_polarity = helper.UpdateByte(portb_polarity, (byte) (pin - 8), polarity);
                helper.WriteI2CByte(i2cbus, IPOLB, portb_polarity);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Sets the mirror status of the interrupt pins.
        /// </summary>
        /// <param name="value">
        ///     0 = The INT pins are not mirrored. INTA is associated with PortA and INTB is associated with PortB.
        ///     1 = The INT pins are internally connected
        /// </param>
        public void MirrorInterrupts(byte value)
        {
            CheckConnected();

            switch (value)
            {
                case 0:
                    config = helper.UpdateByte(config, 6, false);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                case 1:
                    config = helper.UpdateByte(config, 6, true);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(value));
            }
        }

        /// <summary>
        ///     This sets the polarity of the INT output pins.
        /// </summary>
        /// <param name="value">1 = Active - high. 0 = Active - low.</param>
        public void SetInterruptPolarity(byte value)
        {
            CheckConnected();

            switch (value)
            {
                case 0:
                    config = helper.UpdateByte(config, 1, false);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                case 1:
                    config = helper.UpdateByte(config, 1, true);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(value));
            }
        }

        /// <summary>
        ///     This sets the INT output pins to be active driver or open-drain.
        ///     Setting to open-drain overrides the interrupt polarity.
        /// </summary>
        /// <param name="value">1 = Open Drain. 0 = Active Driver.</param>
        public void SetInterruptOutputType(byte value)
        {
            CheckConnected();

            switch (value)
            {
                case 0:
                    config = helper.UpdateByte(config, 2, false);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                case 1:
                    config = helper.UpdateByte(config, 2, true);
                    helper.WriteI2CByte(i2cbus, IOCON, config);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(value));
            }
        }

        /// <summary>
        ///     Sets the type of interrupt for each pin on the selected <paramref name="port"/>.
        ///     1 = interrupt is fired when the pin matches the default value.
        ///     0 = the interrupt is fired on state change.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void SetInterruptType(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, INTCONA, value);
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, INTCONB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     These bits set the compare value for pins configured for interrupt-on-change
        ///     on the selected <paramref name="port"/>. If the associated pin level is the
        ///     opposite from the register bit, an interrupt occurs.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void SetInterruptDefaults(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, DEFVALA, value);
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, DEFVALB, value);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Enable interrupts for the pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        /// <param name="value">number between 0 and 255 or 0x00 and 0xFF</param>
        public void SetInterruptOnPort(byte port, byte value)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    helper.WriteI2CByte(i2cbus, GPINTENA, value);
                    intA = value;
                    break;
                case 1:
                    helper.WriteI2CByte(i2cbus, GPINTENB, value);
                    intB = value;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Enable interrupts for the selected <paramref name="pin"/>.
        /// </summary>
        /// <param name="pin">1 to 16</param>
        /// <param name="value">0 = interrupt disabled, 1 = interrupt enabled</param>
        public void SetInterruptOnPin(byte pin, bool value)
        {
            CheckConnected();

            pin = (byte) (pin - 1);
            if (pin < 8)
            {
                intA = helper.UpdateByte(intA, pin, value);
                helper.WriteI2CByte(i2cbus, GPINTENA, intA);
            }
            else if (pin >= 8 && pin < 16)
            {
                intB = helper.UpdateByte(intB, (byte) (pin - 8), value);
                helper.WriteI2CByte(i2cbus, GPINTENB, intB);
            }
            else
            {
                throw new ArgumentOutOfRangeException(nameof(pin));
            }
        }

        /// <summary>
        ///     Read the interrupt status for the pins on the selected <paramref name="port"/>.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        public byte ReadInterruptStatus(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    return helper.ReadI2CByte(i2cbus, INTFA);
                case 1:
                    return helper.ReadI2CByte(i2cbus, INTFB);
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Read the value from the selected <paramref name="port"/> at the time
        ///     of the last interrupt trigger.
        /// </summary>
        /// <param name="port">0 = pins 1 to 8, 1 = pins 9 to 16</param>
        public byte ReadInterruptCapture(byte port)
        {
            CheckConnected();

            switch (port)
            {
                case 0:
                    return helper.ReadI2CByte(i2cbus, INTCAPA);
                case 1:
                    return helper.ReadI2CByte(i2cbus, INTCAPB);
                default:
                    throw new ArgumentOutOfRangeException(nameof(port));
            }
        }

        /// <summary>
        ///     Reset the interrupts A and B to 0.
        /// </summary>
        public void ResetInterrupts()
        {
            CheckConnected();

            ReadInterruptCapture(0);
            ReadInterruptCapture(1);
        }

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }

        /// <summary>
        ///     get the value of a <paramref name="register"/> from the MCP23017.
        /// </summary>
        /// <param name="register">0 to 255</param>
        /// <returns>Register Value</returns>
        public byte GetRegister(byte register)
        {
            CheckConnected();

            return helper.ReadI2CByte(i2cbus, register);
        }


        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                i2cbus?.Dispose();
                i2cbus = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }
    }
}
<file_sep>/DemoApplication/ExpanderPi.xaml.cs
﻿using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using System.Threading;
using ABElectronics_Win10IOT_Libraries;


namespace DemoApplication
{
    /// <summary>
    /// This demonstration shows how to use the Expander Pi class to write to and read from the analogue and digital inputs
    /// </summary>
    public sealed partial class ExpanderPi : Page
    {

        public ABElectronics_Win10IOT_Libraries.ExpanderPi expi = new ABElectronics_Win10IOT_Libraries.ExpanderPi();

        // create two timers.  _timer 1 reads from the IO and ADC.  _timer2 updates the date from the RTC at 1 second intervals
        int TIMER1_INTERVAL_IN_MILLISECONDS = 200;
        int TIMER2_INTERVAL_IN_MILLISECONDS = 1000;
        Timer _timer1;
        Timer _timer2;

        // used to set the expander pi direction.  true = read, false = write.
        bool IO_Direction = true;

        public ExpanderPi()
        {
            this.InitializeComponent();
            // initialise the timers with the preset period
            _timer1 = new Timer(Timer1_Tick, null, TIMER1_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            _timer2 = new Timer(Timer2_Tick, null, TIMER2_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);

        }

        private async void bt_expi_Connect_Click(object sender, RoutedEventArgs e)
        {
            // when the connect button is clicked check that the RTC Pi is not already connected before creating a Connected event handler and connecting to the RTC Pi
            if (!expi.IsConnected)
            {
                expi.Connected += expi_Connected;
                await expi.Connect();
            }           
        }

        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // dispose of the expander pi and go back to the main page
            expi.Dispose();
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }


        private void expi_Connected(object sender, EventArgs e)
        {
            // expander pi 1 is connected so update the message box, read from the expander pi and start the timer
            WriteMessage("expander pi Connected");

            // set the ADC reference voltage to 4.096V
            expi.ADCSetRefVoltage(4.096);

            radio_IO_Read.IsChecked = true;
            radio_DACGain1.IsChecked = true;

            RefeshDisplay();
            _timer1.Change(TIMER1_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            _timer2.Change(TIMER2_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
        }

        private void Timer1_Tick(Object state)
        {
            // on timer tick check if the expander pi is connected and read from the expander pi before resetting the timer
            if (expi.IsConnected)
            {
                RefeshDisplay();
                _timer1.Change(TIMER1_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);                
            }
        }

        private async void Timer2_Tick(Object state)
        {
            // on timer 2 tick check if the expander pi is connected and read from the expander pi before resetting the timer
            if (expi.IsConnected)
            {
                try
                {
                    // read the current date and time from the RTC Pi into a DateTime object
                    DateTime date = expi.RTCReadDate();

                    // invoke a dispatcher to update the date textbox on the page
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        txt_ClockOut.Text = date.ToString("d MMMM yyyy hh:mm:ss tt");
                    });
                }
                catch
                {
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        txt_ClockOut.Text = "Error reading date";
                    });
                }
                _timer2.Change(TIMER2_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
            }
        }

        private bool GetBit(byte b, int bitNumber)
        {
            return (b & (1 << bitNumber)) != 0;
        }

        private async void WriteMessage(string message)
        {
            // this method updates the Message textbox on the page
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                txt_Message.Text = message;
            });
        }

        private async void RefeshDisplay()
        {
            // check that the expander pi is connected
            if (expi.IsConnected)
            {
                try
                {
                    // invoke the dispatcher to update the checkboxes for expander pi IO ports with the values read from each pin
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {
                        // check if the IO Pi is in read mode

                        if (radio_IO_Read.IsChecked == true)
                        {

                            // read the values from ports 0 and 1 into two byte variables and check 
                            // the status of each variable to find the pin status
                            // this is faster than reading each pin individually
                            byte port0 = expi.IOReadPort(0);
                            byte port1 = expi.IOReadPort(1);

                            chk_IO_Channel_01.IsChecked = GetBit(port0, 0);
                            chk_IO_Channel_02.IsChecked = GetBit(port0, 1);
                            chk_IO_Channel_03.IsChecked = GetBit(port0, 2);
                            chk_IO_Channel_04.IsChecked = GetBit(port0, 3);
                            chk_IO_Channel_05.IsChecked = GetBit(port0, 4);
                            chk_IO_Channel_06.IsChecked = GetBit(port0, 5);
                            chk_IO_Channel_07.IsChecked = GetBit(port0, 6);
                            chk_IO_Channel_08.IsChecked = GetBit(port0, 7);
                            chk_IO_Channel_09.IsChecked = GetBit(port1, 0);
                            chk_IO_Channel_10.IsChecked = GetBit(port1, 1);
                            chk_IO_Channel_11.IsChecked = GetBit(port1, 2);
                            chk_IO_Channel_12.IsChecked = GetBit(port1, 3);
                            chk_IO_Channel_13.IsChecked = GetBit(port1, 4);
                            chk_IO_Channel_14.IsChecked = GetBit(port1, 5);
                            chk_IO_Channel_15.IsChecked = GetBit(port1, 6);
                            chk_IO_Channel_16.IsChecked = GetBit(port1, 7);

                        }

                        // read the adc values and update the textblocks
                        txt_ADC1.Text = expi.ADCReadVoltage(1, 0).ToString("#.###");
                        txt_ADC2.Text = expi.ADCReadVoltage(2, 0).ToString("#.###");
                        txt_ADC3.Text = expi.ADCReadVoltage(3, 0).ToString("#.###");
                        txt_ADC4.Text = expi.ADCReadVoltage(4, 0).ToString("#.###");
                        txt_ADC5.Text = expi.ADCReadVoltage(5, 0).ToString("#.###");
                        txt_ADC6.Text = expi.ADCReadVoltage(6, 0).ToString("#.###");
                        txt_ADC7.Text = expi.ADCReadVoltage(7, 0).ToString("#.###");
                        txt_ADC8.Text = expi.ADCReadVoltage(8, 0).ToString("#.###");


                    }
                    );

                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }

        private async void UpdateClock()
        {
            // Updates the clock label from the RTC clock value

            // check that the expander pi is connected
            if (expi.IsConnected)
            {
                try
                {
                    // invoke the dispatcher to update the checkboxes for expander pi IO ports with the values read from each pin
                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                    {

                    }
                    );

                }
                catch (Exception e)
                {
                    throw e;
                }
            }
        }


        private void IO_SetDirection(object sender, RoutedEventArgs e)
        {
            // read the values from the direction radio buttons and update the expander pi 2 ports using the SetPortDirection method
            if (radio_IO_Read.IsChecked == true)
            {
                if (expi.IsConnected)
                {
                    expi.IOSetPortDirection(0, 0xFF);
                    expi.IOSetPortDirection(1, 0xFF);
                    IO_Direction = true;

                    WriteMessage("IO Reading");
                }
                else
                {
                    radio_IO_Read.IsChecked = false;
                    WriteMessage("expander pi not connected");
                }
            }
            if (radio_IO_Write.IsChecked == true)
            {
                if (expi.IsConnected)
                {
                    expi.IOSetPortDirection(0, 0x00);
                    expi.IOSetPortDirection(1, 0x00);
                    IO_Direction = false;

                    WriteMessage("IO Writing");
                }
                else
                {
                    radio_IO_Write.IsChecked = false;
                    WriteMessage("expander pi not connected");
                }
            }
        }


        private void IO_EnablePullups(object sender, RoutedEventArgs e)
        {
            // get the value from the pull-ups checkbox and set the port pull-ups to the required state using the SetPortPullups method
            CheckBox cb = (CheckBox)sender;
            if (expi.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    expi.IOSetPortPullups(0, 0xFF);
                    expi.IOSetPortPullups(1, 0xFF);
                }
                else
                {
                    expi.IOSetPortPullups(0, 0x00);
                    expi.IOSetPortPullups(1, 0x00);
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("expander pi not connected");
            }
        }

        private void IO_InvertPort(object sender, RoutedEventArgs e)
        {
            // get the value from the invert port checkbox and set the port to the required state using the InvertPort method
            CheckBox cb = (CheckBox)sender;
            if (expi.IsConnected)
            {
                if (cb.IsChecked == true)
                {
                    expi.IOInvertPort(0, 0xFF);
                    expi.IOInvertPort(1, 0xFF);

                    WriteMessage("IO Inverted");
                }
                else
                {
                    expi.IOInvertPort(0, 0x00);
                    expi.IOInvertPort(1, 0x00);

                    WriteMessage("IO not inverted");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("expander pi not connected");
            }
        }

        private void IO_EnablePort0(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (expi.IsConnected == true)
            {
                if (IO_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        expi.IOWritePort(0, 0xFF);
                    }
                    else
                    {
                        expi.IOWritePort(0, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("expander pi not connected.");
            }
        }

        private void IO_EnablePort1(object sender, RoutedEventArgs e)
        {
            // get the value from the enable port checkbox and set the port values to the required state using the WritePort method
            CheckBox cb = (CheckBox)sender;
            if (expi.IsConnected == true)
            {
                if (IO_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        expi.IOWritePort(1, 0xFF);
                    }
                    else
                    {
                        expi.IOWritePort(1, 0x00);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a port state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("expander pi not connected.");
            }
        }

        private void IO_PinEnable(object sender, RoutedEventArgs e)
        {
            // check which pin checkbox was clicked and update the value of that pin to the required state
            CheckBox cb = (CheckBox)sender;
            if (expi.IsConnected == true)
            {
                if (IO_Direction == false)
                {
                    if (cb.IsChecked == true)
                    {
                        expi.IOWritePin(Convert.ToByte(cb.Content.ToString()), true);
                    }
                    else
                    {
                        expi.IOWritePin(Convert.ToByte(cb.Content.ToString()), false);
                    }
                }
                else
                {
                    cb.IsChecked = false;
                    WriteMessage("You can not set a pin state in read mode.");
                }
            }
            else
            {
                cb.IsChecked = false;
                WriteMessage("expander pi not connected.");
            }
        }


        

        

        private void updateDAC(byte channel)
        {
            if (expi.IsConnected)
            {
                double newvoltage = 0;

                if (channel == 1)
                {
                    newvoltage = slider_DACChannel1.Value;
                }
                else
                {
                    newvoltage = slider_DACChannel2.Value;
                }                

                // check to see if the gain is set to 1
                if (radio_DACGain1.IsChecked == true)
                {
                    // write the value to the dac channel 1
                    expi.DACSetVoltage(channel, newvoltage, 1);
                }
                else // gain is set to 2
                {
                    // double the value in newvoltage before writing it to the DAC
                    newvoltage = newvoltage * 2;
                    expi.DACSetVoltage(channel, newvoltage, 2);
                }
            }
            else
            {
                WriteMessage("expander pi not connected.");
            }
        }

        private void DACChannel1_Changed(object sender, Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e)
        {
            updateDAC(1);
        }

        private void DACChannel2_Changed(object sender, Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e)
        {
            updateDAC(2);
        }

        private void radio_DACGain1_Checked(object sender, RoutedEventArgs e)
        {
            updateDAC(1);
            updateDAC(2);
        }

        private void radio_DACGain2_Checked(object sender, RoutedEventArgs e)
        {
            updateDAC(1);
            updateDAC(2);
        }


        private void bt_SetDate_Click(object sender, RoutedEventArgs e)
        {
            if (expi.IsConnected)
            {
                // create a new DateTime object using the values from the Date and Time pickers
                DateTime newdate = new DateTime(picker_NewDate.Date.Year, picker_NewDate.Date.Month, picker_NewDate.Date.Day, picker_NewTime.Time.Hours, picker_NewTime.Time.Minutes, picker_NewTime.Time.Seconds);

                // update the RTC Pi with the new DateTime object
                expi.RTCSetDate(newdate);
            }
        }

        private void cb_sqw_clicked(object sender, RoutedEventArgs e)
        {
            // check the value for the SQW checkbox and enable or disable the square wave output pin
            if (expi.IsConnected)
            {
                if (cb_sqw.IsChecked == true)
                {
                    radio_frequency_clicked(null, null);
                    expi.RTCEnableOutput();
                }
                else
                {
                    expi.RTCDisableOutput();
                }

            }
        }

        private void radio_frequency_clicked(object sender, RoutedEventArgs e)
        {
            // check which frequency radio button has been clicked and update the frequency for the square wave output
            if (expi.IsConnected)
            {
                if (radio_frequency1.IsChecked == true)
                {
                    expi.RTCSetFrequency(1);
                }
                if (radio_frequency2.IsChecked == true)
                {
                    expi.RTCSetFrequency(2);
                }
                if (radio_frequency3.IsChecked == true)
                {
                    expi.RTCSetFrequency(3);
                }
                if (radio_frequency4.IsChecked == true)
                {
                    expi.RTCSetFrequency(4);
                }

            }
        }
    }
}
<file_sep>/ABElectronics_Win10IOT_Libraries/RTCPi.cs
﻿using System;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;
using Windows.Foundation.Metadata;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    ///     Class for controlling the RTC Pi and RTC Pi Plus expansion boards from AB Electronics UK
    ///     Based on the DS1307 real-time clock from Maxim.
    /// </summary>
    public class RTCPi : IDisposable
    {
        // Register addresses for the DS1307 IC
        private const byte SECONDS = 0x00;
        private const byte MINUTES = 0x01;
        private const byte HOURS = 0x02;
        private const byte DAYOFWEEK = 0x03;
        private const byte DAY = 0x04;
        private const byte MONTH = 0x05;
        private const byte YEAR = 0x06;
        private const byte CONTROL = 0x07;

        // the DS1307 does not store the current century so that has to be added on manually.
        private readonly int century = 2000;

        // initial configuration - square wave and output disabled, frequency set to 32.768KHz.
        private byte config = 0x03;
        private readonly ABE_Helpers helper = new ABE_Helpers();

        private I2cDevice i2cbus; // create an instance of the i2c bus.

        // variables
        private readonly byte rtcAddress = 0x68; // I2C address

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

        /// <summary>
        ///     Create an instance of a RTC Pi bus.
        /// </summary>
        public RTCPi()
        {
            IsConnected = false;
        }

        /// <summary>
        ///     Shows if there is a connection with the RTC Pi.
        /// </summary>
        public bool IsConnected { get; private set; }

        /// <summary>
        ///     Open a connection with the RTC Pi.
        /// </summary>
        /// <returns></returns>
        public async Task Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.I2c.I2cDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            /* Initialize the I2C bus */
            try
            {
                var aqs = I2cDevice.GetDeviceSelector(ABE_Helpers.I2C_CONTROLLER_NAME); // Find the selector string for the I2C bus controller
                var dis = await DeviceInformation.FindAllAsync(aqs); // Find the I2C bus controller device with our selector string

                if (dis.Count == 0)
                {
                    return; // Controller not found
                }

                var settings = new I2cConnectionSettings(rtcAddress) {BusSpeed = I2cBusSpeed.FastMode};

                i2cbus = await I2cDevice.FromIdAsync(dis[0].Id, settings); // Create an I2cDevice with our selected bus controller and I2C settings
                if (i2cbus != null)
                {
                    // i2c bus is connected so set IsConnected to true and fire the Connected event handler
                    IsConnected = true;

                    // Fire the Connected event handler
                    Connected?.Invoke(this, EventArgs.Empty);
                }
            }
            catch (Exception ex)
            {
                IsConnected = false;
                throw new Exception("I2C Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;


        /// <summary>
        ///     Converts BCD format to integer.
        /// </summary>
        /// <param name="x">BCD formatted byte</param>
        /// <returns></returns>
        private int BCDtoInt(byte x)
        {
            return x - 6 * (x >> 4);
        }

        /// <summary>
        ///     Converts byte to BCD format.
        /// </summary>
        /// <param name="val">value to convert</param>
        /// <returns>Converted byte</returns>
        private byte BytetoBCD(int val)
        {
            return (byte) (val / 10 * 16 + val % 10);
        }


        /// <summary>
        ///     Set the date and time on the RTC.
        /// </summary>
        /// <param name="date">DateTime</param>
        public void SetDate(DateTime date)
        {
            CheckConnected();

            helper.WriteI2CByte(i2cbus, SECONDS, BytetoBCD(date.Second));
            helper.WriteI2CByte(i2cbus, MINUTES, BytetoBCD(date.Minute));
            helper.WriteI2CByte(i2cbus, HOURS, BytetoBCD(date.Hour));
            helper.WriteI2CByte(i2cbus, DAYOFWEEK, BytetoBCD((int) date.DayOfWeek));
            helper.WriteI2CByte(i2cbus, DAY, BytetoBCD(date.Day));
            helper.WriteI2CByte(i2cbus, MONTH, BytetoBCD(date.Month));
            helper.WriteI2CByte(i2cbus, YEAR, BytetoBCD(date.Year - century));
        }

        /// <summary>
        ///     Read the date and time from the RTC.
        /// </summary>
        /// <returns>DateTime</returns>
        public DateTime ReadDate()
        {
            CheckConnected();

            var DateArray = helper.ReadI2CBlockData(i2cbus, 0, 7);
            var year = BCDtoInt(DateArray[6]) + century;
            var month = BCDtoInt(DateArray[5]);
            var day = BCDtoInt(DateArray[4]);
            // var dayofweek = BCDtoInt(DateArray[3]);
            var hours = BCDtoInt(DateArray[2]);
            var minutes = BCDtoInt(DateArray[1]);
            var seconds = BCDtoInt(DateArray[0]);

            try
            {
                var date = new DateTime(year, month, day, hours, minutes, seconds);
                return date;
            }
            catch
            {
                var date = new DateTime(1990, 01, 01, 01, 01, 01);
                return date;
            }
        }

        /// <summary>
        ///     Enable the clock output pin.
        /// </summary>
        public void EnableOutput()
        {
            CheckConnected();

            config = helper.UpdateByte(config, 7, true);
            config = helper.UpdateByte(config, 4, true);
            helper.WriteI2CByte(i2cbus, CONTROL, config);
        }

        /// <summary>
        ///     Disable the clock output pin.
        /// </summary>
        public void DisableOutput()
        {
            CheckConnected();

            config = helper.UpdateByte(config, 7, false);
            config = helper.UpdateByte(config, 4, false);
            helper.WriteI2CByte(i2cbus, CONTROL, config);
        }

        /// <summary>
        ///     Set the frequency of the output pin square-wave.
        /// </summary>
        /// <param name="frequency">options are: 1 = 1Hz, 2 = 4.096KHz, 3 = 8.192KHz, 4 = 32.768KHz</param>
        public void SetFrequency(byte frequency)
        {
            CheckConnected();

            switch (frequency)
            {
                case 1:
                    config = helper.UpdateByte(config, 0, false);
                    config = helper.UpdateByte(config, 1, false);
                    break;
                case 2:
                    config = helper.UpdateByte(config, 0, true);
                    config = helper.UpdateByte(config, 1, false);
                    break;
                case 3:
                    config = helper.UpdateByte(config, 0, false);
                    config = helper.UpdateByte(config, 1, true);
                    break;
                case 4:
                    config = helper.UpdateByte(config, 0, true);
                    config = helper.UpdateByte(config, 1, true);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(frequency));
            }
            helper.WriteI2CByte(i2cbus, CONTROL, config);
        }

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }


        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                i2cbus?.Dispose();
                i2cbus = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }
    }
}<file_sep>/DemoApplication/MainPage.xaml.cs
﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace DemoApplication
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        Frame rootFrame = Window.Current.Content as Frame;

        public MainPage()
        {
            this.InitializeComponent();
        }

        private void iopi_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(IOPi));
        }

        private void adc_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(ADCPi));
        }

        private void adcdifferentialpi_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(ADCDifferentialPi));
        }

        private void expanderpi_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(ExpanderPi));
        }

        private void rtc_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(RTCPi));
        }

        private void adcdac_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(ADCDACPi));
        }

        private void servo_Click(object sender, RoutedEventArgs e)
        {
            rootFrame.Navigate(typeof(ServoPi));
        }

    }
}
<file_sep>/DemoApplication/ADCDACPi.xaml.cs
﻿using System;
using System.Threading;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;


namespace DemoApplication
{
    /// <summary>
    /// This demonstration for the ADCDAC Pi shows how to read from the ADC and write to the DAC
    /// </summary>
    public sealed partial class ADCDACPi : Page
    {
        // create an instance of the ADCDAC class
        ABElectronics_Win10IOT_Libraries.ADCDACPi adcdac = new ABElectronics_Win10IOT_Libraries.ADCDACPi();       

        // variables for storing the ADC values
        double ADC1_value = 0;
        double ADC2_value = 0;

        // A timer for reading from the ADC
        Timer _timer;

        // set a time interval for reading from the ADC
        int TIME_INTERVAL_IN_MILLISECONDS = 50;

        public ADCDACPi()
        {
            this.InitializeComponent();
        }

        
        private void bt_Connect_Click(object sender, RoutedEventArgs e)
        {
            // when the connect button is clicked set the ADC reference voltage, create an event handler for the Connected event and connect to the ADCDAC Pi.
            adcdac.SetADCrefVoltage(3.3);
            adcdac.Connected += Adcdac_Connected;
            adcdac.Connect();
        }

        private void Adcdac_Connected(object sender, EventArgs e)
        {
            // The ADCDAC Pi is connected to start the timer to read from the ADC channels
            _timer = new Timer(ReadADC, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
        }

        private async void ReadADC(object state)
        {
            // Get the values from both ADC channels and store them in two variables.
            ADC1_value = adcdac.ReadADCVoltage(1);
            ADC2_value = adcdac.ReadADCVoltage(2);

            // use a dispatcher event to update the textboxes on the page with the saved values
            await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {                
                txt_ADC1.Text = ADC1_value.ToString("F3");
                txt_ADC2.Text = ADC2_value.ToString("F3");
            });

            // reset the timer so it will trigger again after the set period
            _timer = new Timer(ReadADC, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite);
        }

        

        private void DAC1SliderChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            // get the new value from slider 1 and use it to update the DAC channel 1
            double dac_value = slider_Channel1.Value;
            adcdac.SetDACVoltage(1, dac_value);
        }

        private void DAC2SliderChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            // get the new value from slider 2 and use it to update the DAC channel 2
            double dac_value = slider_Channel2.Value;
            adcdac.SetDACVoltage(2, dac_value);
        }

        private void bt_Back_Clicked(object sender, RoutedEventArgs e)
        {
            // go back to the main page
            adcdac.Dispose();
            Frame rootFrame = Window.Current.Content as Frame;
            rootFrame.Navigate(typeof(MainPage));
        }


    }
}
<file_sep>/ABElectronics_Win10IOT_Libraries/ServoPi.cs
﻿using System;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.Gpio;
using Windows.Devices.I2c;
using Windows.Foundation.Metadata;

namespace ABElectronics_Win10IOT_Libraries
{
    /// <summary>
    ///     Class for controlling the Servo Pi expansion board from AB Electronics UK
    ///     Based on the PCA9685 PWM controller IC from NXT.
    /// </summary>
    public class ServoPi : IDisposable
    {
        private readonly byte ALL_LED_OFF_H = 0xFD;
        private readonly byte ALL_LED_OFF_L = 0xFC;
        private readonly byte ALL_LED_ON_H = 0xFB;
        private readonly byte ALL_LED_ON_L = 0xFA;
        private GpioController gpio;
        private readonly ABE_Helpers helper = new ABE_Helpers();

        // create an instance of the i2c bus and GPIO controller
        private I2cDevice i2cbus;
        private readonly byte LED0_OFF_H = 0x09;
        private readonly byte LED0_OFF_L = 0x08;
        private readonly byte LED0_ON_H = 0x07;
        private readonly byte LED0_ON_L = 0x06;

        // Define registers values from the datasheet
        private readonly byte MODE1 = 0x00;
        private GpioPin pin;
        private readonly byte PRE_SCALE = 0xFE;

        // Flag: Has Dispose already been called?
        bool disposed = false;
        // Instantiate a SafeHandle instance.
        System.Runtime.InteropServices.SafeHandle handle = new Microsoft.Win32.SafeHandles.SafeFileHandle(IntPtr.Zero, true);

        /// <summary>
        ///     Create an instance of a Servo Pi bus.
        /// </summary>
        /// <param name="address">I2C address of Servo Pi bus</param>
        /// <param name="outputEnablePin">GPIO pin for Output Enable function (0-disabled)</param>
        /// <example>ABElectronics_Win10IOT_Libraries.ServoPi servo = new ABElectronics_Win10IOT_Libraries.ServoPi();</example>
        public ServoPi(byte address = 0x40, byte outputEnablePin = 0)
        {
            Address = address;
            IsConnected = false;
            OutputEnablePin = outputEnablePin;
        }


        /// <summary>
        ///     I2C address for the Servo Pi bus.
        /// </summary>
        /// <example>servopi.Address = 0x40;</example>
        public byte Address { get; set; }

        /// <summary>
        ///     Set the GPIO pin for the output enable function.
        ///     The default GPIO pin 4 is not supported in Windows 10 IOT so the OE pad will need to be connected to a different
        ///     GPIO pin.
        /// </summary>
        /// <example>servopi.OutputEnablePin = 17;</example>
        public byte OutputEnablePin { get; set; }

        /// <summary>
        ///     Shows if there is a connection with the Servo Pi
        /// </summary>
        /// <example>if (servopi.IsConnected) { }</example>
        public bool IsConnected { get; private set; }

        /// <summary>
        ///     Open a connection with the Servo Pi
        /// </summary>
        /// <returns></returns>
        /// <example>servopi.Connect();</example>
        public async Task Connect()
        {
            if (IsConnected)
            {
                return; // Already connected
            }

            if (!ApiInformation.IsTypePresent("Windows.Devices.I2c.I2cDevice"))
            {
                return; // This system does not support this feature: can't connect
            }

            /* Initialize the I2C bus */
            try
            {
                var aqs = I2cDevice.GetDeviceSelector(ABE_Helpers.I2C_CONTROLLER_NAME); // Find the selector string for the I2C bus controller
                var dis = await DeviceInformation.FindAllAsync(aqs); // Find the I2C bus controller device with our selector string

                if (dis.Count == 0)
                {
                    return; // Controller not found
                }

                var settings = new I2cConnectionSettings(Address) {BusSpeed = I2cBusSpeed.FastMode};

                i2cbus = await I2cDevice.FromIdAsync(dis[0].Id, settings);
                    /* Create an I2cDevice with our selected bus controller and I2C settings */
                if (i2cbus != null)
                {
                    // Connection is established so set IsConnected to true

                    IsConnected = true;

                    helper.WriteI2CByte(i2cbus, MODE1, 0x00);

                    // Check to see if the output pin has been set and if so try to connect to the GPIO pin on the Raspberry Pi
                    if (OutputEnablePin != 0)
                    {
                        gpio = GpioController.GetDefault();

                        if (gpio != null)
                        {
                            GpioOpenStatus status;

                            gpio.TryOpenPin(OutputEnablePin, GpioSharingMode.Exclusive, out pin, out status);
                            if (status == GpioOpenStatus.PinOpened)
                            {
                                // Latch HIGH value first. This ensures a default value when the pin is set as output
                                pin.Write(GpioPinValue.High);
                                // Set the IO direction as output
                                pin.SetDriveMode(GpioPinDriveMode.Output);
                            }
                        }
                    }

                    // Fire the Connected event handler
                    Connected?.Invoke(this, EventArgs.Empty);
                }
                else
                {
                    IsConnected = false;
                }
            }
            catch (Exception ex)
            {
                IsConnected = false;
                throw new Exception("I2C Initialization Failed", ex);
            }
        }

        /// <summary>
        ///     Event occurs when connection is made.
        /// </summary>
        public event EventHandler Connected;

        /// <summary>
        ///     Set the output frequency of all PWM channels.
        ///     The output frequency is programmable from a typical 40Hz to 1000Hz.
        /// </summary>
        /// <param name="freq">Integer frequency value</param>
        /// <example>servopi.SetPWMFreqency(500);</example>
        public void SetPWMFreqency(int freq)
        {
            var scaleval = 25000000.0; // 25MHz
            scaleval /= 4096.0; // 12-bit
            scaleval /= freq;
            scaleval -= 1.0;
            var prescale = Math.Floor(scaleval + 0.5);
            var oldmode = helper.ReadI2CByte(i2cbus, MODE1);
            var newmode = (byte) ((oldmode & 0x7F) | 0x10);
            helper.WriteI2CByte(i2cbus, MODE1, newmode);
            helper.WriteI2CByte(i2cbus, PRE_SCALE, (byte) Math.Floor(prescale));
            helper.WriteI2CByte(i2cbus, MODE1, oldmode);
            helper.WriteI2CByte(i2cbus, MODE1, (byte) (oldmode | 0x80));
        }

        /// <summary>
        ///     Set the PWM output on a single <paramref name="channel"/>.
        /// </summary>
        /// <param name="channel">1 to 16</param>
        /// <param name="on">Value between 0 and 4096</param>
        /// <param name="off">Value between 0 and 4096</param>
        /// <example>servopi.SetPWM(1,512,1024);</example>
        public void SetPWM(byte channel, short on, short off)
        {
            channel = (byte) (channel - 1);
            helper.WriteI2CByte(i2cbus, (byte) (LED0_ON_L + 4 * channel), (byte) (on & 0xFF));
            helper.WriteI2CByte(i2cbus, (byte) (LED0_ON_H + 4 * channel), (byte) (on >> 8));
            helper.WriteI2CByte(i2cbus, (byte) (LED0_OFF_L + 4 * channel), (byte) (off & 0xFF));
            helper.WriteI2CByte(i2cbus, (byte) (LED0_OFF_H + 4 * channel), (byte) (off >> 8));
        }

        /// <summary>
        ///     Set PWM output on all channels.
        /// </summary>
        /// <param name="on">Value between 0 and 4096</param>
        /// <param name="off">Value between 0 and 4096</param>
        /// <example>servopi.SetAllPWM(512,1024);</example>
        public void SetAllPWM(short on, short off)
        {
            helper.WriteI2CByte(i2cbus, ALL_LED_ON_L, (byte) (on & 0xFF));
            helper.WriteI2CByte(i2cbus, ALL_LED_ON_H, (byte) (on >> 8));
            helper.WriteI2CByte(i2cbus, ALL_LED_OFF_L, (byte) (off & 0xFF));
            helper.WriteI2CByte(i2cbus, ALL_LED_OFF_H, (byte) (off >> 8));
        }

        /// <summary>
        ///     Disable output via OE pin.  Only used when the OE jumper is joined.
        /// </summary>
        /// <example>servopi.OutputDisable();</example>
        public void OutputDisable()
        {
            if (pin == null)
            {
                throw new InvalidOperationException("OutputEnablePin was not set for the .Connect().");
            }

            pin.Write(GpioPinValue.High);
        }

        /// <summary>
        ///     Enable output via OE pin.  Only used when the OE jumper is joined.
        /// </summary>
        /// <example>servopi.OutputEnable();</example>
        public void OutputEnable()
        {
            if (pin == null)
            {
                throw new InvalidOperationException("OutputEnablePin was not set for the .Connect().");
            }

            pin.Write(GpioPinValue.Low);
        }

        private void CheckConnected()
        {
            if (!IsConnected)
            {
                throw new InvalidOperationException("Not connected. You must call .Connect() first.");
            }
        }

        /// <summary>
        ///     Dispose of the resources
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Protected implementation of Dispose pattern
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (disposed)
                return;

            if (disposing)
            {
                handle.Dispose();
                // Free any other managed objects here.
                i2cbus?.Dispose();
                i2cbus = null;

                IsConnected = false;
            }

            // Free any unmanaged objects here.
            //
            disposed = true;
        }
    }
}<file_sep>/DemoApplication_VB/bin/ARM/Release/ilc/ImplTypes.g.cs
#define MCG_WINRT_SUPPORTED
using Mcg.System;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.WindowsRuntime;


// -----------------------------------------------------------------------------------------------------------
// 
// WARNING: THIS SOURCE FILE IS FOR 32-BIT BUILDS ONLY!
// 
// MCG GENERATED CODE
// 
// This C# source file is generated by MCG and is added into the application at compile time to support interop features.
// 
// It has three primary components:
// 
// 1. Public type definitions with interop implementation used by this application including WinRT & COM data structures and P/Invokes.
// 
// 2. The 'McgInterop' class containing marshaling code that acts as a bridge from managed code to native code.
// 
// 3. The 'McgNative' class containing marshaling code and native type definitions that call into native code and are called by native code.
// 
// -----------------------------------------------------------------------------------------------------------
// 
// warning CS0067: The event 'event' is never used
#pragma warning disable 67
// warning CS0169: The field 'field' is never used
#pragma warning disable 169
// warning CS0649: Field 'field' is never assigned to, and will always have its default value 0
#pragma warning disable 414
// warning CS0414: The private field 'field' is assigned but its value is never used
#pragma warning disable 649
// warning CS1591: Missing XML comment for publicly visible type or member 'Type_or_Member'
#pragma warning disable 1591
// warning CS0108 'member1' hides inherited member 'member2'. Use the new keyword if hiding was intended.
#pragma warning disable 108
// warning CS0114 'member1' hides inherited member 'member2'.  To make the current method override that implementation, add the override keyword. Otherwise add the new keyword.
#pragma warning disable 114
// warning CS0659 'type' overrides Object.Equals but does not override GetHashCode.
#pragma warning disable 659
// warning CS0465 Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?
#pragma warning disable 465
// warning CS0028 'function declaration' has the wrong signature to be an entry point
#pragma warning disable 28
// warning CS0162 Unreachable code Detected
#pragma warning disable 162
// warning CS0628 new protected member declared in sealed class
#pragma warning disable 628

namespace System
{
	// System.EventHandler<Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>
	public unsafe static class EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>, global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'System.EventHandler<Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl.System_EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_System_EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget95>(global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.IDatePickerValueChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class System_EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// System.EventHandler<Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>
	public unsafe static class EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>, global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'System.EventHandler<Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl.System_EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_System_EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget97>(global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITimePickerValueChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class System_EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// System.Nullable<Windows.UI.Color>
	public unsafe static class Nullable_A_Windows_UI_Color_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Color>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Color>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Color__Windows_UI__Color, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Color get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Color unsafe___value__retval;
				global::Windows.UI.Color __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Color>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Color_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Color>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Color>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.CornerRadius>
	public unsafe static class Nullable_A_Windows_UI_Xaml_CornerRadius_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.CornerRadius>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.CornerRadius>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_CornerRadius__Windows_UI_Xaml__CornerRadius, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.CornerRadius get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.CornerRadius unsafe___value__retval;
				global::Windows.UI.Xaml.CornerRadius __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.CornerRadius>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_CornerRadius_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.CornerRadius>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.CornerRadius>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Duration>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Duration_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Duration>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Duration>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Duration__Windows_UI_Xaml__Duration, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Duration get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Duration unsafe___value__retval;
				global::Windows.UI.Xaml.Duration __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Duration>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Duration_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Duration>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Duration>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.GridLength>
	public unsafe static class Nullable_A_Windows_UI_Xaml_GridLength_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.GridLength>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.GridLength get_Value(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.GridLength __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_GridLength__<global::Windows.Foundation.IReference<global::Windows.UI.Xaml.GridLength>>(
									__this, 
									global::System.Nullable_A_Windows_UI_Xaml_GridLength_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.GridLength>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.GridLength>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Thickness>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Thickness_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Thickness>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Thickness get_Value(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Thickness __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Thickness__<global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Thickness>>(
									__this, 
									global::System.Nullable_A_Windows_UI_Xaml_Thickness_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Thickness>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Thickness>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Controls_Primitives_GeneratorPosition_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Controls_Primitives_GeneratorPosition__Windows_UI_Xaml_Controls_Primitives__GeneratorPosition, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Controls.Primitives.GeneratorPosition get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Controls.Primitives.GeneratorPosition unsafe___value__retval;
				global::Windows.UI.Xaml.Controls.Primitives.GeneratorPosition __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Controls_Primitives_GeneratorPosition_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Controls.Primitives.GeneratorPosition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Media.Matrix>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Media_Matrix_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Media.Matrix>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Media.Matrix>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Media_Matrix__Windows_UI_Xaml_Media__Matrix, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Matrix get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Media.Matrix unsafe___value__retval;
				global::Windows.UI.Xaml.Media.Matrix __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Matrix>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Media_Matrix_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Media.Matrix>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Matrix>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Media.Animation.KeyTime>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Media_Animation_KeyTime_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Media.Animation.KeyTime>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Media.Animation.KeyTime>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Media_Animation_KeyTime__Windows_UI_Xaml_Media_Animation__KeyTime, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Animation.KeyTime get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Media.Animation.KeyTime unsafe___value__retval;
				global::Windows.UI.Xaml.Media.Animation.KeyTime __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Animation.KeyTime>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Media_Animation_KeyTime_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Media.Animation.KeyTime>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Animation.KeyTime>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Media.Animation.RepeatBehavior>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Media_Animation_RepeatBehavior_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Media.Animation.RepeatBehavior>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Media.Animation.RepeatBehavior>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Media_Animation_RepeatBehavior__Windows_UI_Xaml_Media_Animation__RepeatBehavior, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Animation.RepeatBehavior get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Media.Animation.RepeatBehavior unsafe___value__retval;
				global::Windows.UI.Xaml.Media.Animation.RepeatBehavior __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Animation.RepeatBehavior>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Media_Animation_RepeatBehavior_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Media.Animation.RepeatBehavior>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Animation.RepeatBehavior>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.UI.Xaml.Media.Media3D.Matrix3D>
	public unsafe static class Nullable_A_Windows_UI_Xaml_Media_Media3D_Matrix3D_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.UI.Xaml.Media.Media3D.Matrix3D>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.UI.Xaml.Media.Media3D.Matrix3D>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_Media_Media3D_Matrix3D__Windows_UI_Xaml_Media_Media3D__Matrix3D, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Media3D.Matrix3D get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Media.Media3D.Matrix3D unsafe___value__retval;
				global::Windows.UI.Xaml.Media.Media3D.Matrix3D __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Media3D.Matrix3D>).TypeHandle, 
									global::System.Nullable_A_Windows_UI_Xaml_Media_Media3D_Matrix3D_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<Windows.UI.Xaml.Media.Media3D.Matrix3D>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.UI.Xaml.Media.Media3D.Matrix3D>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Vector2>
	public unsafe static class Nullable_A_System_Numerics_Vector2_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Vector2>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Vector2>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Vector2__Windows_Foundation_Numerics__Vector2, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Vector2 get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Vector2 unsafe___value__retval;
				global::System.Numerics.Vector2 __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector2>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Vector2_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Vector2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Vector3>
	public unsafe static class Nullable_A_System_Numerics_Vector3_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Vector3>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Vector3>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Vector3__Windows_Foundation_Numerics__Vector3, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Vector3 get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Vector3 unsafe___value__retval;
				global::System.Numerics.Vector3 __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector3>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Vector3_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Vector3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Vector4>
	public unsafe static class Nullable_A_System_Numerics_Vector4_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Vector4>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Vector4>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Vector4__Windows_Foundation_Numerics__Vector4, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Vector4 get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Vector4 unsafe___value__retval;
				global::System.Numerics.Vector4 __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector4>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Vector4_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Vector4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Vector4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Matrix3x2>
	public unsafe static class Nullable_A_System_Numerics_Matrix3x2_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Matrix3x2>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Matrix3x2>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Matrix3x2__Windows_Foundation_Numerics__Matrix3x2, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Matrix3x2 get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Matrix3x2 unsafe___value__retval;
				global::System.Numerics.Matrix3x2 __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Matrix3x2>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Matrix3x2_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Matrix3x2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Matrix3x2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Matrix4x4>
	public unsafe static class Nullable_A_System_Numerics_Matrix4x4_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Matrix4x4>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Matrix4x4>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Matrix4x4__Windows_Foundation_Numerics__Matrix4x4, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Matrix4x4 get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Matrix4x4 unsafe___value__retval;
				global::System.Numerics.Matrix4x4 __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Matrix4x4>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Matrix4x4_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Matrix4x4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Matrix4x4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Plane>
	public unsafe static class Nullable_A_System_Numerics_Plane_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Plane>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Plane>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Plane__Windows_Foundation_Numerics__Plane, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Plane get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Plane unsafe___value__retval;
				global::System.Numerics.Plane __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Plane>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Plane_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Plane>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Plane>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<System.Numerics.Quaternion>
	public unsafe static class Nullable_A_System_Numerics_Quaternion_V___Impl
	{
		// StubClass for 'System.Nullable<System.Numerics.Quaternion>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<System.Numerics.Quaternion>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Numerics_Quaternion__Windows_Foundation_Numerics__Quaternion, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Numerics.Quaternion get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Numerics.Quaternion unsafe___value__retval;
				global::System.Numerics.Quaternion __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.IReference<global::System.Numerics.Quaternion>).TypeHandle, 
									global::System.Nullable_A_System_Numerics_Quaternion_V___Impl.Vtbl.idx_get_Value, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// v-table for 'System.Nullable<System.Numerics.Quaternion>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::System.Numerics.Quaternion>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.System.Threading.TimerElapsedHandler>
	public unsafe static class Nullable_A_Windows_System_Threading_TimerElapsedHandler_V___Impl
	{
		// StubClass for 'System.Nullable<Windows.System.Threading.TimerElapsedHandler>'
		public static partial class StubClass
		{
			// Signature, System.Nullable<Windows.System.Threading.TimerElapsedHandler>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_System_Threading_TimerElapsedHandler__Windows_System_Threading__TimerElapsedHandler *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.System.Threading.TimerElapsedHandler get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl** unsafe___value__retval = default(global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl**);
				global::Windows.System.Threading.TimerElapsedHandler __value__retval = default(global::Windows.System.Threading.TimerElapsedHandler);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IReference<global::Windows.System.Threading.TimerElapsedHandler>).TypeHandle, 
										global::System.Nullable_A_Windows_System_Threading_TimerElapsedHandler_V___Impl.Vtbl.idx_get_Value, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = (global::Windows.System.Threading.TimerElapsedHandler)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToDelegate(
										((global::System.IntPtr)unsafe___value__retval), 
										typeof(global::Windows.System.Threading.TimerElapsedHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget121>(global::Windows.System.Threading.TimerElapsedHandler__Impl.Invoke)
									);
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval)));
				}
			}
		}

		// v-table for 'System.Nullable<Windows.System.Threading.TimerElapsedHandler>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.System.Threading.TimerElapsedHandler>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.EventHandler<Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>
	public unsafe static class EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>, global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'System.EventHandler<Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl.System_EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_System_EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl_Vtbl_s_theCcwVta" +
				"ble")]
			public static global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget124>(global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class System_EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<uint,uint>>
	public unsafe static class Nullable_A_Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V__V___Impl
	{
		// StubClass for 'System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<uint,uint>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> get_Value(global::System.__ComObject __this)
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> __ret = global::McgInterop.ForwardComSharedStubs.Func__AsyncOperationProgressHandler_2_uint__uint___<global::Windows.Foundation.IReference<global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>>>(
									__this, 
									global::System.Nullable_A_Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V__V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// v-table for 'System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<uint,uint>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<Windows.Storage.Streams.IBuffer,uint>>
	public unsafe static class Nullable_A_Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V__V___Impl
	{
		// StubClass for 'System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<Windows.Storage.Streams.IBuffer,uint>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> get_Value(global::System.__ComObject __this)
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> __ret = global::McgInterop.ForwardComSharedStubs.Func__AsyncOperationProgressHandler_2_Storage_Streams_IBuffer__uint___<global::Windows.Foundation.IReference<global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>>>(
									__this, 
									global::System.Nullable_A_Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V__V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// v-table for 'System.Nullable<Windows.Foundation.AsyncOperationProgressHandler<Windows.Storage.Streams.IBuffer,uint>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReference<global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}
}

namespace System.Collections.Generic
{
	// System.Collections.Generic.IReadOnlyList<byte>
	public unsafe static class IReadOnlyList_A_byte_V___Impl
	{
		// v-table for 'System.Collections.Generic.IReadOnlyList<byte>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<byte>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>
	public unsafe static class IList_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>, global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Add(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Contains(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.CopyTo(
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeer[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Remove(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			int global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.IndexOf(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IndexOf(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Insert(
						int index, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeer item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Insert(
									this, 
									index, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.RemoveAt(int index)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.RemoveAt(
									this, 
									index
								);
			}
		}

		// v-table for 'System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_GetView = 8;
			internal const int idx_IndexOf = 9;
			internal const int idx_SetAt = 10;
			internal const int idx_InsertAt = 11;
			internal const int idx_RemoveAt = 12;
			internal const int idx_Append = 13;
			internal const int idx_RemoveAtEnd = 14;
			internal const int idx_Clear = 15;
			internal const int idx_GetMany = 16;
			internal const int idx_ReplaceAll = 17;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeer>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
	public unsafe static class IList_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>, global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Add(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Contains(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.CopyTo(
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Remove(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			int global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.IndexOf(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IndexOf(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.Insert(
						int index, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Insert(
									this, 
									index, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.RemoveAt(int index)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.RemoveAt(
									this, 
									index
								);
			}
		}

		// v-table for 'System.Collections.Generic.IList<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_GetView = 8;
			internal const int idx_IndexOf = 9;
			internal const int idx_SetAt = 10;
			internal const int idx_InsertAt = 11;
			internal const int idx_RemoveAt = 12;
			internal const int idx_Append = 13;
			internal const int idx_RemoveAtEnd = 14;
			internal const int idx_Clear = 15;
			internal const int idx_GetMany = 16;
			internal const int idx_ReplaceAll = 17;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl
	{
		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.Foundation.Point>
	public unsafe static class IEnumerable_A_Windows_Foundation_Point_V___Impl
	{
		// v-table for 'System.Collections.Generic.IEnumerable<Windows.Foundation.Point>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>
	public unsafe static class IEnumerable_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IDictionary<System.Object,System.Object>
	public unsafe static class IDictionary_A_System_Object_j_System_Object_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IDictionary<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IDictionary<object, object>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<object>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IDictionary<object, object>, global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Add(global::System.Collections.Generic.KeyValuePair<object, object> item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Contains(global::System.Collections.Generic.KeyValuePair<object, object> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.CopyTo(
						global::System.Collections.Generic.KeyValuePair<object, object>[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Remove(global::System.Collections.Generic.KeyValuePair<object, object> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			object global::System.Collections.Generic.IDictionary<object, object>.this[object index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			global::System.Collections.Generic.ICollection<object> global::System.Collections.Generic.IDictionary<object, object>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.ICollection<object> global::System.Collections.Generic.IDictionary<object, object>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			void global::System.Collections.Generic.IDictionary<object, object>.Add(
						object key, 
						object value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									key, 
									value
								);
			}

			bool global::System.Collections.Generic.IDictionary<object, object>.ContainsKey(object key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<object, object>.Remove(object key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<object, object>.TryGetValue(
						object key, 
						out object value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}
		}

		// v-table for 'System.Collections.Generic.IDictionary<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IDictionary<object, object>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<object>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Lookup = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_HasKey = 8;
			internal const int idx_GetView = 9;
			internal const int idx_Insert = 10;
			internal const int idx_Remove = 11;
			internal const int idx_Clear = 12;
		}
	}

	// System.Collections.Generic.KeyValuePair<System.Object,System.Object>
	public unsafe static class KeyValuePair_A_System_Object_j_System_Object_V___Impl
	{
		// StubClass for 'System.Collections.Generic.KeyValuePair<System.Object,System.Object>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object get_Key(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.Foundation.Collections.IKeyValuePair<object, object>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl.idx_get_Key
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object get_Value(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.Foundation.Collections.IKeyValuePair<object, object>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.KeyValuePair<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<object, object>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IKeyValuePair<object, object>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Key")]
			object global::Windows.Foundation.Collections.IKeyValuePair<object, object>.get_Key()
			{
				object __retVal = global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.StubClass.get_Key(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Value")]
			object global::Windows.Foundation.Collections.IKeyValuePair<object, object>.get_Value()
			{
				object __retVal = global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Collections.Generic.KeyValuePair<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<object, object>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Key = 6;
			internal const int idx_get_Value = 7;
		}
	}

	// System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>
	public unsafe static class IEnumerable_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl
	{
		// StubClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>> First(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>>(
									__this, 
									global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.Vtbl.idx_First
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}
		}

		[System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object,object>>))]
		public class DynamicRCWAdapterClass : global::System.Runtime.InteropServices.ComInterfaceDynamicAdapter, global::System.Collections.IEnumerable
		{
		    public global::System.Collections.IEnumerator GetEnumerator()
		    {
		        return new IIterator_PrivateRCWAdapter<global::System.Collections.Generic.KeyValuePair<object,object>>(global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.StubClass.First(ComObject));
		    }
		}

		// v-table for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyDictionary<System.Object,System.Object>
	public unsafe static class IReadOnlyDictionary_A_System_Object_j_System_Object_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyDictionary<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyDictionary<object, object>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyDictionary<object, object>, global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<object, object>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<object, object>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<object, object>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Count_Get(this);
				}
			}

			object global::System.Collections.Generic.IReadOnlyDictionary<object, object>.this[object index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
			}

			global::System.Collections.Generic.IEnumerable<object> global::System.Collections.Generic.IReadOnlyDictionary<object, object>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.IEnumerable<object> global::System.Collections.Generic.IReadOnlyDictionary<object, object>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<object, object>.ContainsKey(object key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<object, object>.TryGetValue(
						object key, 
						out object value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyDictionary<System.Object,System.Object>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyDictionary<object, object>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Lookup = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_HasKey = 8;
			internal const int idx_Split = 9;
		}
	}

	// System.Collections.Generic.IList<Windows.UI.Xaml.UIElement>
	public unsafe static class IList_A_Windows_UI_Xaml_UIElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IList<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>, global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.Add(global::Windows.UI.Xaml.UIElement item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.Contains(global::Windows.UI.Xaml.UIElement item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.CopyTo(
						global::Windows.UI.Xaml.UIElement[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>.Remove(global::Windows.UI.Xaml.UIElement item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			global::Windows.UI.Xaml.UIElement global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			int global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>.IndexOf(global::Windows.UI.Xaml.UIElement item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IndexOf(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>.Insert(
						int index, 
						global::Windows.UI.Xaml.UIElement item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Insert(
									this, 
									index, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>.RemoveAt(int index)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.RemoveAt(
									this, 
									index
								);
			}
		}

		// v-table for 'System.Collections.Generic.IList<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.UIElement>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.UIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_GetView = 8;
			internal const int idx_IndexOf = 9;
			internal const int idx_SetAt = 10;
			internal const int idx_InsertAt = 11;
			internal const int idx_RemoveAt = 12;
			internal const int idx_Append = 13;
			internal const int idx_RemoveAtEnd = 14;
			internal const int idx_Clear = 15;
			internal const int idx_GetMany = 16;
			internal const int idx_ReplaceAll = 17;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.UIElement>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_UIElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.UIElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.UIElement>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_UIElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.UIElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.UIElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.UIElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.UIElement>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.UIElement>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.UIElement global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.UIElement>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.UIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IList<Windows.UI.Xaml.Controls.RowDefinition>
	public unsafe static class IList_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IList<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>, global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Add(global::Windows.UI.Xaml.Controls.RowDefinition item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Contains(global::Windows.UI.Xaml.Controls.RowDefinition item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.CopyTo(
						global::Windows.UI.Xaml.Controls.RowDefinition[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Remove(global::Windows.UI.Xaml.Controls.RowDefinition item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			global::Windows.UI.Xaml.Controls.RowDefinition global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			int global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>.IndexOf(global::Windows.UI.Xaml.Controls.RowDefinition item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IndexOf(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>.Insert(
						int index, 
						global::Windows.UI.Xaml.Controls.RowDefinition item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Insert(
									this, 
									index, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>.RemoveAt(int index)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.RemoveAt(
									this, 
									index
								);
			}
		}

		// v-table for 'System.Collections.Generic.IList<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_GetView = 8;
			internal const int idx_IndexOf = 9;
			internal const int idx_SetAt = 10;
			internal const int idx_InsertAt = 11;
			internal const int idx_RemoveAt = 12;
			internal const int idx_Append = 13;
			internal const int idx_RemoveAtEnd = 14;
			internal const int idx_Clear = 15;
			internal const int idx_GetMany = 16;
			internal const int idx_ReplaceAll = 17;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.RowDefinition>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.RowDefinition>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Controls.RowDefinition>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.RowDefinition>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Controls.RowDefinition>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Controls.RowDefinition global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Controls.RowDefinition>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.DependencyObject>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_DependencyObject_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.DependencyObject> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.DependencyObject>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.DependencyObject>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IDependencyObject_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject2>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IDependencyObject2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IUIElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElementOverrides>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElementOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElementOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement2>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IUIElement2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement3>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IUIElement3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement4>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_IUIElement4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.IRowDefinition>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.IRowDefinition> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.IRowDefinition>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IList<Windows.UI.Xaml.Documents.Inline>
	public unsafe static class IList_A_Windows_UI_Xaml_Documents_Inline_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IList<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>, global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.Add(global::Windows.UI.Xaml.Documents.Inline item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.Contains(global::Windows.UI.Xaml.Documents.Inline item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.CopyTo(
						global::Windows.UI.Xaml.Documents.Inline[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>.Remove(global::Windows.UI.Xaml.Documents.Inline item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			global::Windows.UI.Xaml.Documents.Inline global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			int global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>.IndexOf(global::Windows.UI.Xaml.Documents.Inline item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.IndexOf(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>.Insert(
						int index, 
						global::Windows.UI.Xaml.Documents.Inline item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.Insert(
									this, 
									index, 
									item
								);
			}

			void global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>.RemoveAt(int index)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IVectorSharedReferenceTypesRCWAdapter.RemoveAt(
									this, 
									index
								);
			}
		}

		// v-table for 'System.Collections.Generic.IList<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Documents.Inline>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<global::Windows.UI.Xaml.Documents.Inline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_GetView = 8;
			internal const int idx_IndexOf = 9;
			internal const int idx_SetAt = 10;
			internal const int idx_InsertAt = 11;
			internal const int idx_RemoveAt = 12;
			internal const int idx_Append = 13;
			internal const int idx_RemoveAtEnd = 14;
			internal const int idx_Clear = 15;
			internal const int idx_GetMany = 16;
			internal const int idx_ReplaceAll = 17;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.Inline>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_Inline_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.Inline>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_Inline_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.Inline>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.Inline>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.Inline>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.Inline global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.Inline>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.Inline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.TextElement>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_TextElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.TextElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.TextElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElementOverrides>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElementOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement2>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement3>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.IInline>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Documents_IInline_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.IInline> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.IInline>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IDictionary<string,string>
	public unsafe static class IDictionary_A_string_j_string_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IDictionary<string,string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IDictionary<string, string>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<string>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IDictionary<string, string>, global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}

			int global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Add(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Contains(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.CopyTo(
						global::System.Collections.Generic.KeyValuePair<string, string>[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Remove(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			string global::System.Collections.Generic.IDictionary<string, string>.this[string index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			global::System.Collections.Generic.ICollection<string> global::System.Collections.Generic.IDictionary<string, string>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.ICollection<string> global::System.Collections.Generic.IDictionary<string, string>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			void global::System.Collections.Generic.IDictionary<string, string>.Add(
						string key, 
						string value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									key, 
									value
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.ContainsKey(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.Remove(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.TryGetValue(
						string key, 
						out string value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}
		}

		// v-table for 'System.Collections.Generic.IDictionary<string,string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IDictionary<string, string>))]
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.ICollection<string>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Lookup = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_HasKey = 8;
			internal const int idx_GetView = 9;
			internal const int idx_Insert = 10;
			internal const int idx_Remove = 11;
			internal const int idx_Clear = 12;
		}
	}

	// System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,string>>
	public unsafe static class IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl
	{
		// StubClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,string>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>> First(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>>(
									__this, 
									global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.Vtbl.idx_First
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,string>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}
		}

		[System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string,string>>))]
		public class DynamicRCWAdapterClass : global::System.Runtime.InteropServices.ComInterfaceDynamicAdapter, global::System.Collections.IEnumerable
		{
		    public global::System.Collections.IEnumerator GetEnumerator()
		    {
		        return new IIterator_PrivateRCWAdapter<global::System.Collections.Generic.KeyValuePair<string,string>>(global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.StubClass.First(ComObject));
		    }
		}

		// v-table for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,string>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyDictionary<string,string>
	public unsafe static class IReadOnlyDictionary_A_string_j_string_V___Impl
	{
		// v-table for 'System.Collections.Generic.IReadOnlyDictionary<string,string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyDictionary<string, string>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Lookup = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_HasKey = 8;
			internal const int idx_Split = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyDictionary<string,Windows.ApplicationModel.Resources.Core.NamedResource>
	public unsafe static class IReadOnlyDictionary_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyDictionary<string,Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>, global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Count_Get(this);
				}
			}

			global::Windows.ApplicationModel.Resources.Core.NamedResource global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.this[string index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
			}

			global::System.Collections.Generic.IEnumerable<string> global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource> global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.ContainsKey(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.TryGetValue(
						string key, 
						out global::Windows.ApplicationModel.Resources.Core.NamedResource value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyDictionary<string,Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Lookup = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_HasKey = 8;
			internal const int idx_Split = 9;
		}
	}

	// System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>
	public unsafe static class KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl
	{
		// StubClass for 'System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Key(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_get_Key
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.NamedResource get_Value(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.NamedResource __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>, global::Windows.ApplicationModel.Resources.Core.NamedResource>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Key")]
			string global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.get_Key()
			{
				string __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.get_Key(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Value")]
			global::Windows.ApplicationModel.Resources.Core.NamedResource global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.get_Value()
			{
				global::Windows.ApplicationModel.Resources.Core.NamedResource __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Key = 6;
			internal const int idx_get_Value = 7;
		}
	}

	// System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>
	public unsafe static class IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl
	{
		// StubClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>> First(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>>(
									__this, 
									global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.Vtbl.idx_First
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>
		{
			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}
		}

		[System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string,global::Windows.ApplicationModel.Resources.Core.NamedResource>>))]
		public class DynamicRCWAdapterClass : global::System.Runtime.InteropServices.ComInterfaceDynamicAdapter, global::System.Collections.IEnumerable
		{
		    public global::System.Collections.IEnumerator GetEnumerator()
		    {
		        return new IIterator_PrivateRCWAdapter<global::System.Collections.Generic.KeyValuePair<string,global::Windows.ApplicationModel.Resources.Core.NamedResource>>(global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.StubClass.First(ComObject));
		    }
		}

		// v-table for 'System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.DeviceInformation>
	public unsafe static class IReadOnlyList_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.DeviceInformation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.DeviceInformation> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.DeviceInformation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.DeviceInformation>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
									);
				}
			}

			global::Windows.Devices.Enumeration.DeviceInformation global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.Devices.Enumeration.DeviceInformation>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.DeviceInformation>
	public unsafe static class IEnumerable_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.DeviceInformation> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.DeviceInformation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.DependencyObject>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_DependencyObject_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.DependencyObject>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.DependencyObject> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.DependencyObject>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.DependencyObject>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.DependencyObject>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.DependencyObject global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.DependencyObject>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.DependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IDependencyObject_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IDependencyObject>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IDependencyObject>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IDependencyObject global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IDependencyObject>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject2>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IDependencyObject2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IDependencyObject2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IDependencyObject2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IDependencyObject2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IDependencyObject2 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IDependencyObject2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IDependencyObject2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.IRowDefinition>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Controls.IRowDefinition>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.IRowDefinition> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Controls.IRowDefinition>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Controls.IRowDefinition>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Controls.IRowDefinition global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Controls.IRowDefinition>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IUIElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IUIElement global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IUIElement>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElementOverrides>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElementOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElementOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElementOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElementOverrides>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IUIElementOverrides global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IUIElementOverrides>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement2>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IUIElement2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IUIElement2 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IUIElement2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement3>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IUIElement3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement3>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IUIElement3 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IUIElement3>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement4>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_IUIElement4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.IUIElement4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.IUIElement4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.IUIElement4>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.IUIElement4 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.IUIElement4>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.IUIElement4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.TextElement>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_TextElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.TextElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.TextElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.TextElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.TextElement>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.TextElement global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.TextElement>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.TextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.ITextElement global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.ITextElement>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElementOverrides>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElementOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElementOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.ITextElementOverrides global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.ITextElementOverrides>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement2>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.ITextElement2 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.ITextElement2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement3>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.ITextElement3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.ITextElement3>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.ITextElement3 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.ITextElement3>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.IInline>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Documents_IInline_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.IInline>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.IInline> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Documents.IInline>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Documents.IInline>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Documents.IInline global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Documents.IInline>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Documents.IInline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.NamedResource>
	public unsafe static class IEnumerable_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.ApplicationModel.Resources.Core.NamedResource> global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.ApplicationModel.Resources.Core.NamedResource>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.INamedResource>
	public unsafe static class IEnumerable_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.INamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.ApplicationModel.Resources.Core.INamedResource> global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.ApplicationModel.Resources.Core.INamedResource>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.ApplicationModel.Resources.Core.INamedResource>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.ApplicationModel.Resources.Core.INamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.INamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
	public unsafe static class IReadOnlyList_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
									);
				}
			}

			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5 global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>
	public unsafe static class IEnumerable_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation> global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>
	public unsafe static class KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl
	{
		// StubClass for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Key(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl.idx_get_Key
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_Value(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Key")]
			string global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>.get_Key()
			{
				string __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.StubClass.get_Key(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Value")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>.get_Value()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Key = 6;
			internal const int idx_get_Value = 7;
		}
	}

	// System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>
	public unsafe static class KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl
	{
		// StubClass for 'System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Type get_Key(global::System.__ComObject __this)
			{
				global::System.Type __ret = global::McgInterop.ForwardComSharedStubs.Func_Type__<global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl.idx_get_Key
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_Value(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Key")]
			global::System.Type global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>.get_Key()
			{
				global::System.Type __retVal = global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.StubClass.get_Key(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Value")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>.get_Value()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Key = 6;
			internal const int idx_get_Value = 7;
		}
	}

	// System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>
	public unsafe static class KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl
	{
		// StubClass for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Key(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.Vtbl.idx_get_Key
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlMember get_Value(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>, global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Key")]
			string global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>.get_Key()
			{
				string __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.StubClass.get_Key(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IKeyValuePair`2.Value")]
			global::Windows.UI.Xaml.Markup.IXamlMember global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>.get_Value()
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __retVal = global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Key = 6;
			internal const int idx_get_Value = 7;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation>
	public unsafe static class IEnumerable_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation2>
	public unsafe static class IEnumerable_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation2> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IIterableSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
								);
			}
		}

		// v-table for 'System.Collections.Generic.IEnumerable<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_First = 6;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation>
	public unsafe static class IReadOnlyList_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.IDeviceInformation>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.IDeviceInformation>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
									);
				}
			}

			global::Windows.Devices.Enumeration.IDeviceInformation global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.Devices.Enumeration.IDeviceInformation>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation2>
	public unsafe static class IReadOnlyList_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl
	{
		// DispatchClass for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>, global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.IDeviceInformation2>
		{
			global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation2> global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>.GetEnumerator()
			{
				global::System.RuntimeTypeHandle dummySharedDynamicAdapter = typeof(global::System.Runtime.InteropServices.WindowsRuntime.IVectorViewSharedReferenceTypesDynamicAdapter<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle;
				return (global::System.Collections.Generic.IEnumerator<global::Windows.Devices.Enumeration.IDeviceInformation2>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
								);
			}

			int global::System.Collections.Generic.IReadOnlyCollection<global::Windows.Devices.Enumeration.IDeviceInformation2>.Count
			{
				get
				{
					return global::McgInterop.McgHelpers.GetReadOnlyCollectionCount(
										this, 
										typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
									);
				}
			}

			global::Windows.Devices.Enumeration.IDeviceInformation2 global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>.this[int index]
			{
				get
				{
					return global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IReadOnlyListAdapter<global::Windows.Devices.Enumeration.IDeviceInformation2>>(global::System.Runtime.InteropServices.McgModuleManager.GetDynamicAdapter(
											this, 
											typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle
										))[index];
				}
			}
		}

		// v-table for 'System.Collections.Generic.IReadOnlyList<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Collections.Generic.IReadOnlyList<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetAt = 6;
			internal const int idx_get_Size = 7;
			internal const int idx_IndexOf = 8;
			internal const int idx_GetMany = 9;
		}
	}
}

namespace System.Runtime.InteropServices
{
	// System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime
	public unsafe static class IMarshal__System_Runtime_WindowsRuntime__Impl
	{
		// StubClass for 'System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime'
		public static partial class StubClass
		{
			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetUnmarshalClass, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetUnmarshalClass(
						global::System.__ComObject __this, 
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlFlags, 
						out global::System.Guid pCid)
			{
				// Setup
				global::System.Guid unsafe_riid;
				global::System.Guid unsafe_pCid;
				int unsafe___return__;
				// Marshalling
				unsafe_riid = riid;
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.IMarshal,System.Runtime.WindowsRuntime, Version=4.0.10.0, Culture=neutral, Public" +
											"KeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_GetUnmarshalClass, 
									&(unsafe_riid), 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlFlags, 
									&(unsafe_pCid)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				pCid = unsafe_pCid;
				// Return
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetMarshalSizeMax, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetMarshalSizeMax(
						global::System.__ComObject __this, 
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlflags, 
						out uint pSize)
			{
				// Setup
				global::System.Guid unsafe_riid;
				uint unsafe_pSize;
				int unsafe___return__;
				// Marshalling
				unsafe_riid = riid;
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.IMarshal,System.Runtime.WindowsRuntime, Version=4.0.10.0, Culture=neutral, Public" +
											"KeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_GetMarshalSizeMax, 
									&(unsafe_riid), 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlflags, 
									&(unsafe_pSize)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				pSize = unsafe_pSize;
				// Return
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.MarshalInterface, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void MarshalInterface(
						global::System.__ComObject __this, 
						global::System.IntPtr pStm, 
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlflags)
			{
				// Setup
				global::System.Guid unsafe_riid;
				int unsafe___return__;
				// Marshalling
				unsafe_riid = riid;
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.IMarshal,System.Runtime.WindowsRuntime, Version=4.0.10.0, Culture=neutral, Public" +
											"KeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_MarshalInterface, 
									pStm, 
									&(unsafe_riid), 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlflags
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.UnmarshalInterface, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void UnmarshalInterface(
						global::System.__ComObject __this, 
						global::System.IntPtr pStm, 
						ref global::System.Guid riid, 
						out global::System.IntPtr ppv)
			{
				// Setup
				global::System.Guid unsafe_riid;
				global::System.IntPtr unsafe_ppv;
				int unsafe___return__;
				// Marshalling
				unsafe_riid = riid;
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.IMarshal,System.Runtime.WindowsRuntime, Version=4.0.10.0, Culture=neutral, Public" +
											"KeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_UnmarshalInterface, 
									pStm, 
									&(unsafe_riid), 
									&(unsafe_ppv)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				ppv = unsafe_ppv;
				// Return
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.ReleaseMarshalData, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ReleaseMarshalData(
						global::System.__ComObject __this, 
						global::System.IntPtr pStm)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.IMarshal,System.Runtime.WindowsRuntime, Version=4.0.10.0, Culture=neutral, Public" +
											"KeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_ReleaseMarshalData, 
									pStm
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void DisconnectObject(
						global::System.__ComObject __this, 
						uint dwReserved)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_uint__<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(
									__this, 
									dwReserved, 
									global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_DisconnectObject
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetUnmarshalClass(
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlFlags, 
						out global::System.Guid pCid)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.GetUnmarshalClass(
									this, 
									ref riid, 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlFlags, 
									out pCid
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetMarshalSizeMax(
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlflags, 
						out uint pSize)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.GetMarshalSizeMax(
									this, 
									ref riid, 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlflags, 
									out pSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.MarshalInterface(
						global::System.IntPtr pStm, 
						ref global::System.Guid riid, 
						global::System.IntPtr pv, 
						uint dwDestContext, 
						global::System.IntPtr pvDestContext, 
						uint mshlflags)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.MarshalInterface(
									this, 
									pStm, 
									ref riid, 
									pv, 
									dwDestContext, 
									pvDestContext, 
									mshlflags
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.UnmarshalInterface(
						global::System.IntPtr pStm, 
						ref global::System.Guid riid, 
						out global::System.IntPtr ppv)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.UnmarshalInterface(
									this, 
									pStm, 
									ref riid, 
									out ppv
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.ReleaseMarshalData(global::System.IntPtr pStm)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.ReleaseMarshalData(
									this, 
									pStm
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.DisconnectObject(uint dwReserved)
			{
				global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.StubClass.DisconnectObject(
									this, 
									dwReserved
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime
			global::System.IntPtr pfnGetUnmarshalClass_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			global::System.IntPtr pfnGetMarshalSizeMax_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			global::System.IntPtr pfnMarshalInterface_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			global::System.IntPtr pfnUnmarshalInterface_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			global::System.IntPtr pfnReleaseMarshalData_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			global::System.IntPtr pfnDisconnectObject_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime;
			internal const int idx_GetUnmarshalClass = 3;
			internal const int idx_GetMarshalSizeMax = 4;
			internal const int idx_MarshalInterface = 5;
			internal const int idx_UnmarshalInterface = 6;
			internal const int idx_ReleaseMarshalData = 7;
			internal const int idx_DisconnectObject = 8;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.System_Runtime_InteropServices_IMarshal__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer), "RVA_System_Runtime_InteropServices_IMarshal__System_Runtime_WindowsRuntime__Impl_Vtbl_s_theCcwVtable")]
			public static global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetUnmarshalClass_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget157>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.GetUnmarshalClass__STUB),
				pfnGetMarshalSizeMax_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget158>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.GetMarshalSizeMax__STUB),
				pfnMarshalInterface_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget159>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.MarshalInterface__STUB),
				pfnUnmarshalInterface_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget160>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.UnmarshalInterface__STUB),
				pfnReleaseMarshalData_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.ReleaseMarshalData__STUB),
				pfnDisconnectObject_System_Runtime_InteropServices__IMarshal__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget135>(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl.DisconnectObject__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetUnmarshalClass, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [rev] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetUnmarshalClass__STUB(
						global::System.IntPtr pComThis, 
						global::System.Guid* unsafe_riid, 
						global::System.IntPtr unsafe_pv, 
						uint unsafe_dwDestContext, 
						global::System.IntPtr unsafe_pvDestContext, 
						uint unsafe_mshlFlags, 
						global::System.Guid* unsafe_pCid)
			{
				// Setup
				global::System.Guid riid;
				global::System.Guid pCid;
				try
				{
					// Marshalling
					riid = (*(unsafe_riid));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetUnmarshalClass(
										ref riid, 
										unsafe_pv, 
										unsafe_dwDestContext, 
										unsafe_pvDestContext, 
										unsafe_mshlFlags, 
										out pCid
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					(*(unsafe_pCid)) = pCid;
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_pCid != null)
						(*(unsafe_pCid)) = default(global::System.Guid);
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.GetMarshalSizeMax, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [rev] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetMarshalSizeMax__STUB(
						global::System.IntPtr pComThis, 
						global::System.Guid* unsafe_riid, 
						global::System.IntPtr unsafe_pv, 
						uint unsafe_dwDestContext, 
						global::System.IntPtr unsafe_pvDestContext, 
						uint unsafe_mshlflags, 
						uint* unsafe_pSize)
			{
				// Setup
				global::System.Guid riid;
				uint pSize;
				try
				{
					// Marshalling
					riid = (*(unsafe_riid));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetMarshalSizeMax(
										ref riid, 
										unsafe_pv, 
										unsafe_dwDestContext, 
										unsafe_pvDestContext, 
										unsafe_mshlflags, 
										out pSize
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					(*(unsafe_pSize)) = pSize;
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_pSize != null)
						(*(unsafe_pSize)) = 0;
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.MarshalInterface, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int MarshalInterface__STUB(
						global::System.IntPtr pComThis, 
						global::System.IntPtr unsafe_pStm, 
						global::System.Guid* unsafe_riid, 
						global::System.IntPtr unsafe_pv, 
						uint unsafe_dwDestContext, 
						global::System.IntPtr unsafe_pvDestContext, 
						uint unsafe_mshlflags)
			{
				// Setup
				global::System.Guid riid;
				try
				{
					// Marshalling
					riid = (*(unsafe_riid));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).MarshalInterface(
										unsafe_pStm, 
										ref riid, 
										unsafe_pv, 
										unsafe_dwDestContext, 
										unsafe_pvDestContext, 
										unsafe_mshlflags
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.UnmarshalInterface, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [rev] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [rev] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int UnmarshalInterface__STUB(
						global::System.IntPtr pComThis, 
						global::System.IntPtr unsafe_pStm, 
						global::System.Guid* unsafe_riid, 
						global::System.IntPtr* unsafe_ppv)
			{
				// Setup
				global::System.Guid riid;
				global::System.IntPtr ppv;
				try
				{
					// Marshalling
					riid = (*(unsafe_riid));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).UnmarshalInterface(
										unsafe_pStm, 
										ref riid, 
										out ppv
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					(*(unsafe_ppv)) = ppv;
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_ppv != null)
						(*(unsafe_ppv)) = default(global::System.IntPtr);
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			// Signature, System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime.ReleaseMarshalData, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int ReleaseMarshalData__STUB(
						global::System.IntPtr pComThis, 
						global::System.IntPtr unsafe_pStm)
			{
				try
				{
					// Marshalling
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).ReleaseMarshalData(unsafe_pStm);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int DisconnectObject__STUB(
						global::System.IntPtr pComThis, 
						uint unsafe_dwReserved)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime>(
									__this, 
									5
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_uint__(
									__this, 
									unsafe_dwReserved, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class System_Runtime_InteropServices_IMarshal__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "GetUnmarshalClass__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "GetMarshalSizeMax__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "MarshalInterface__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "UnmarshalInterface__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "ReleaseMarshalData__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::System.Runtime.InteropServices.IMarshal__System_Runtime_WindowsRuntime__Impl.Vtbl), "DisconnectObject__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_Runtime_InteropServices_IMarshal__System_Runtime_WindowsRuntime__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime
	public unsafe static class IAgileObject__System_Runtime_WindowsRuntime__Impl
	{
		// v-table for 'System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime__Impl.Vtbl.System_Runtime_InteropServices_IAgileObject__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer), "RVA_System_Runtime_InteropServices_IAgileObject__System_Runtime_WindowsRuntime__Impl_Vtbl_s_theCcwVtable")]
			public static global::System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.Runtime.InteropServices.IAgileObject__System_Runtime_WindowsRuntime__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			private static class System_Runtime_InteropServices_IAgileObject__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_Runtime_InteropServices_IAgileObject__System_Runtime_WindowsRuntime__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// System.Runtime.InteropServices.HSTRING__System_Private_Interop
	public unsafe static class HSTRING__System_Private_Interop__Impl
	{
	}
}

namespace System.Runtime.InteropServices.ComTypes
{
	// System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop
	public unsafe static class ITypeInfo__System_Private_Interop__Impl
	{
		// StubClass for 'System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeAttr(
						global::System.__ComObject __this, 
						out global::System.IntPtr ppTypeAttr)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_out_IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									out ppTypeAttr, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetTypeAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeComp(
						global::System.__ComObject __this, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_out__ComTypes_ITypeComp__Private_Interop__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									out ppTComp, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetTypeComp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetFuncDesc(
						global::System.__ComObject __this, 
						int index, 
						out global::System.IntPtr ppFuncDesc)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out_IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									index, 
									out ppFuncDesc, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetFuncDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetVarDesc(
						global::System.__ComObject __this, 
						int index, 
						out global::System.IntPtr ppVarDesc)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out_IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									index, 
									out ppVarDesc, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetVarDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetNames, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_string__wchar_t * *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] int__int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetNames(
						global::System.__ComObject __this, 
						int memid, 
						string[] rgBstrNames, 
						int cMaxNames, 
						out int pcNames)
			{
				// Setup
				ushort** unsafe_rgBstrNames = default(ushort**);
				int unsafe_pcNames;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (rgBstrNames != null)
						unsafe_rgBstrNames = (ushort**)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(rgBstrNames.Length * sizeof(ushort*))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetNames, 
										memid, 
										unsafe_rgBstrNames, 
										cMaxNames, 
										&(unsafe_pcNames)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					pcNames = unsafe_pcNames;
					if (rgBstrNames != null)
						for (uint mcgIdx = 0; (mcgIdx < rgBstrNames.Length); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.BstrMarshaller] string__wchar_t * rgBstrNames
							rgBstrNames[mcgIdx] = global::McgInterop.Helpers.ConvertBSTRToString(unsafe_rgBstrNames[mcgIdx]);
						}
					// Return
				}
				finally
				{
					// Cleanup
					if (unsafe_rgBstrNames != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < rgBstrNames.Length); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.BstrMarshaller] string__wchar_t * rgBstrNames
							global::System.Runtime.InteropServices.ExternalInterop.SysFreeString(unsafe_rgBstrNames[mcgIdx_1]);
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_rgBstrNames);
				}
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetRefTypeOfImplType, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] int__int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetRefTypeOfImplType(
						global::System.__ComObject __this, 
						int index, 
						out int href)
			{
				// Setup
				int unsafe_href;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
											"icKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetRefTypeOfImplType, 
									index, 
									&(unsafe_href)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				href = unsafe_href;
				// Return
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetImplTypeFlags, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.EnumMarshaller] System_Runtime_InteropServices_ComTypes_IMPLTYPEFLAGS__System_Private_Interop__IMPLTYPEFLAGS__System_Private_Interop, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetImplTypeFlags(
						global::System.__ComObject __this, 
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS__System_Private_Interop pImplTypeFlags)
			{
				// Setup
				global::System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS__System_Private_Interop unsafe_pImplTypeFlags;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
											"icKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetImplTypeFlags, 
									index, 
									&(unsafe_pImplTypeFlags)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				pImplTypeFlags = unsafe_pImplTypeFlags;
				// Return
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetIDsOfNames, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.ArrayMarshaller] rg_string__wchar_t * *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [Mcg.CodeGen.BlittableArrayMarshaller] rg_int__int *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetIDsOfNames(
						global::System.__ComObject __this, 
						string[] rgszNames, 
						int cNames, 
						int[] pMemId)
			{
				// Setup
				ushort** unsafe_rgszNames = default(ushort**);
				int* unsafe_pMemId;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (rgszNames == null)
						unsafe_rgszNames = null;
					else
					{
						if (rgszNames != null)
							unsafe_rgszNames = (ushort**)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(rgszNames.Length * sizeof(ushort*))));
						if (rgszNames != null)
							for (uint mcgIdx = 0; (mcgIdx < rgszNames.Length); mcgIdx++)
							{
								// [fwd] [in] [optional] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t * rgszNames
								unsafe_rgszNames[mcgIdx] = (ushort*)global::McgInterop.McgHelpers.AllocUnicodeBuffer(rgszNames[mcgIdx]);
								global::McgInterop.McgHelpers.CopyUnicodeString(
													rgszNames[mcgIdx], 
													unsafe_rgszNames[mcgIdx]
												);
							}
					}
					fixed (int* pinned_pMemId = global::McgInterop.McgCoreHelpers.GetArrayForCompat(pMemId))
					{
						unsafe_pMemId = (int*)pinned_pMemId;
						// Call to native method
						unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
											__this, 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>"), 
											global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetIDsOfNames, 
											unsafe_rgszNames, 
											cNames, 
											unsafe_pMemId
										);
						global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					}
					// Return
				}
				finally
				{
					// Cleanup
					if (unsafe_rgszNames != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < rgszNames.Length); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t * rgszNames
							global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_rgszNames[mcgIdx_1]);
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_rgszNames);
				}
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.Invoke, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.ObjectMarshaller] object____mcg_IUnknown *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] short__short, [fwd] [in] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableStructMarshaller] System_Runtime_InteropServices_ComTypes_DISPPARAMS__System_Private_Interop__System_Runtime_InteropServices_ComTypes__DISPPARAMS__System_Private_Interop, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] int__int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Invoke(
						global::System.__ComObject __this, 
						object pvInstance, 
						int memid, 
						short wFlags, 
						ref global::System.Runtime.InteropServices.ComTypes.DISPPARAMS__System_Private_Interop pDispParams, 
						global::System.IntPtr pVarResult, 
						global::System.IntPtr pExcepInfo, 
						out int puArgErr)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IUnknown** unsafe_pvInstance = default(global::System.Runtime.InteropServices.__vtable_IUnknown**);
				global::System.Runtime.InteropServices.ComTypes.DISPPARAMS__System_Private_Interop unsafe_pDispParams;
				int unsafe_puArgErr;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_pvInstance = (global::System.Runtime.InteropServices.__vtable_IUnknown**)global::System.Runtime.InteropServices.McgMarshal.ObjectToComInterface(
										pvInstance, 
										global::System.Runtime.InteropServices.McgModuleManager.IUnknown
									);
					unsafe_pDispParams = pDispParams;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_Invoke, 
										unsafe_pvInstance, 
										memid, 
										wFlags, 
										&(unsafe_pDispParams), 
										pVarResult, 
										pExcepInfo, 
										&(unsafe_puArgErr)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					puArgErr = unsafe_puArgErr;
					pDispParams = unsafe_pDispParams;
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_pvInstance)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetDocumentation(
						global::System.__ComObject __this, 
						int index, 
						out string strName, 
						out string strDocString, 
						out int dwHelpContext, 
						out string strHelpFile)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out_string__out_string__out_int__out_string__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									index, 
									out strName, 
									out strDocString, 
									out dwHelpContext, 
									out strHelpFile, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetDocumentation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetDllEntry, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller] System_Runtime_InteropServices_ComTypes_INVOKEKIND__System_Private_Interop__INVOKEKIND__System_Private_Interop, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetDllEntry(
						global::System.__ComObject __this, 
						int memid, 
						global::System.Runtime.InteropServices.ComTypes.INVOKEKIND__System_Private_Interop invKind, 
						global::System.IntPtr pBstrDllName, 
						global::System.IntPtr pBstrName, 
						global::System.IntPtr pwOrdinal)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
											"icKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetDllEntry, 
									memid, 
									invKind, 
									pBstrDllName, 
									pBstrName, 
									pwOrdinal
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetRefTypeInfo(
						global::System.__ComObject __this, 
						int hRef, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTI)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out__ComTypes_ITypeInfo__Private_Interop__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									hRef, 
									out ppTI, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetRefTypeInfo
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.AddressOfMember, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller] System_Runtime_InteropServices_ComTypes_INVOKEKIND__System_Private_Interop__INVOKEKIND__System_Private_Interop, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void AddressOfMember(
						global::System.__ComObject __this, 
						int memid, 
						global::System.Runtime.InteropServices.ComTypes.INVOKEKIND__System_Private_Interop invKind, 
						out global::System.IntPtr ppv)
			{
				// Setup
				global::System.IntPtr unsafe_ppv;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
											"icKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_AddressOfMember, 
									memid, 
									invKind, 
									&(unsafe_ppv)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				ppv = unsafe_ppv;
				// Return
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.CreateInstance, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.ObjectMarshaller] object____mcg_IUnknown *, [fwd] [in] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ObjectMarshaller] object____mcg_IUnknown *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void CreateInstance(
						global::System.__ComObject __this, 
						object pUnkOuter, 
						ref global::System.Guid riid, 
						out object ppvObj)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IUnknown** unsafe_pUnkOuter = default(global::System.Runtime.InteropServices.__vtable_IUnknown**);
				global::System.Guid unsafe_riid;
				global::System.Runtime.InteropServices.__vtable_IUnknown** unsafe_ppvObj = default(global::System.Runtime.InteropServices.__vtable_IUnknown**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_pUnkOuter = (global::System.Runtime.InteropServices.__vtable_IUnknown**)global::System.Runtime.InteropServices.McgMarshal.ObjectToComInterface(
										pUnkOuter, 
										global::System.Runtime.InteropServices.McgModuleManager.IUnknown
									);
					unsafe_riid = riid;
					unsafe_ppvObj = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_CreateInstance, 
										unsafe_pUnkOuter, 
										&(unsafe_riid), 
										&(unsafe_ppvObj)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					ppvObj = (object)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_ppvObj), 
										global::System.Runtime.InteropServices.McgModuleManager.IUnknown
									);
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_pUnkOuter)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppvObj)));
				}
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetMops, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BstrMarshaller] string__wchar_t *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetMops(
						global::System.__ComObject __this, 
						int memid, 
						out string pBstrMops)
			{
				// Setup
				ushort* unsafe_pBstrMops = default(ushort*);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_pBstrMops = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetMops, 
										memid, 
										&(unsafe_pBstrMops)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					pBstrMops = global::McgInterop.Helpers.ConvertBSTRToString(unsafe_pBstrMops);
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.ExternalInterop.SysFreeString(unsafe_pBstrMops);
				}
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetContainingTypeLib, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeLib__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeLib__System_Private_Interop *, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] int__int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetContainingTypeLib(
						global::System.__ComObject __this, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop ppTLB, 
						out int pIndex)
			{
				// Setup
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl** unsafe_ppTLB = default(global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl**);
				int unsafe_pIndex;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_ppTLB = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_GetContainingTypeLib, 
										&(unsafe_ppTLB), 
										&(unsafe_pIndex)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					pIndex = unsafe_pIndex;
					ppTLB = (global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_ppTLB), 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
												"cKeyToken=b03f5f7f11d50a3a")
									);
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTLB)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ReleaseTypeAttr(
						global::System.__ComObject __this, 
						global::System.IntPtr pTypeAttr)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_void__IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									pTypeAttr, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_ReleaseTypeAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ReleaseFuncDesc(
						global::System.__ComObject __this, 
						global::System.IntPtr pFuncDesc)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_void__IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									pFuncDesc, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_ReleaseFuncDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ReleaseVarDesc(
						global::System.__ComObject __this, 
						global::System.IntPtr pVarDesc)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_void__IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop>(
									__this, 
									pVarDesc, 
									global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl.idx_ReleaseVarDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetTypeAttr(out global::System.IntPtr ppTypeAttr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetTypeAttr(
									this, 
									out ppTypeAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetTypeComp(out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetTypeComp(
									this, 
									out ppTComp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetFuncDesc(
						int index, 
						out global::System.IntPtr ppFuncDesc)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetFuncDesc(
									this, 
									index, 
									out ppFuncDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetVarDesc(
						int index, 
						out global::System.IntPtr ppVarDesc)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetVarDesc(
									this, 
									index, 
									out ppVarDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetNames(
						int memid, 
						string[] rgBstrNames, 
						int cMaxNames, 
						out int pcNames)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetNames(
									this, 
									memid, 
									rgBstrNames, 
									cMaxNames, 
									out pcNames
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetRefTypeOfImplType(
						int index, 
						out int href)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetRefTypeOfImplType(
									this, 
									index, 
									out href
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetImplTypeFlags(
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.IMPLTYPEFLAGS__System_Private_Interop pImplTypeFlags)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetImplTypeFlags(
									this, 
									index, 
									out pImplTypeFlags
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetIDsOfNames(
						string[] rgszNames, 
						int cNames, 
						int[] pMemId)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetIDsOfNames(
									this, 
									rgszNames, 
									cNames, 
									pMemId
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.Invoke(
						object pvInstance, 
						int memid, 
						short wFlags, 
						ref global::System.Runtime.InteropServices.ComTypes.DISPPARAMS__System_Private_Interop pDispParams, 
						global::System.IntPtr pVarResult, 
						global::System.IntPtr pExcepInfo, 
						out int puArgErr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.Invoke(
									this, 
									pvInstance, 
									memid, 
									wFlags, 
									ref pDispParams, 
									pVarResult, 
									pExcepInfo, 
									out puArgErr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetDocumentation(
						int index, 
						out string strName, 
						out string strDocString, 
						out int dwHelpContext, 
						out string strHelpFile)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetDocumentation(
									this, 
									index, 
									out strName, 
									out strDocString, 
									out dwHelpContext, 
									out strHelpFile
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetDllEntry(
						int memid, 
						global::System.Runtime.InteropServices.ComTypes.INVOKEKIND__System_Private_Interop invKind, 
						global::System.IntPtr pBstrDllName, 
						global::System.IntPtr pBstrName, 
						global::System.IntPtr pwOrdinal)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetDllEntry(
									this, 
									memid, 
									invKind, 
									pBstrDllName, 
									pBstrName, 
									pwOrdinal
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetRefTypeInfo(
						int hRef, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTI)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetRefTypeInfo(
									this, 
									hRef, 
									out ppTI
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.AddressOfMember(
						int memid, 
						global::System.Runtime.InteropServices.ComTypes.INVOKEKIND__System_Private_Interop invKind, 
						out global::System.IntPtr ppv)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.AddressOfMember(
									this, 
									memid, 
									invKind, 
									out ppv
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.CreateInstance(
						object pUnkOuter, 
						ref global::System.Guid riid, 
						out object ppvObj)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.CreateInstance(
									this, 
									pUnkOuter, 
									ref riid, 
									out ppvObj
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetMops(
						int memid, 
						out string pBstrMops)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetMops(
									this, 
									memid, 
									out pBstrMops
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.GetContainingTypeLib(
						out global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop ppTLB, 
						out int pIndex)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.GetContainingTypeLib(
									this, 
									out ppTLB, 
									out pIndex
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.ReleaseTypeAttr(global::System.IntPtr pTypeAttr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.ReleaseTypeAttr(
									this, 
									pTypeAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.ReleaseFuncDesc(global::System.IntPtr pFuncDesc)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.ReleaseFuncDesc(
									this, 
									pFuncDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop.ReleaseVarDesc(global::System.IntPtr pVarDesc)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.StubClass.ReleaseVarDesc(
									this, 
									pVarDesc
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetTypeAttr = 3;
			internal const int idx_GetTypeComp = 4;
			internal const int idx_GetFuncDesc = 5;
			internal const int idx_GetVarDesc = 6;
			internal const int idx_GetNames = 7;
			internal const int idx_GetRefTypeOfImplType = 8;
			internal const int idx_GetImplTypeFlags = 9;
			internal const int idx_GetIDsOfNames = 10;
			internal const int idx_Invoke = 11;
			internal const int idx_GetDocumentation = 12;
			internal const int idx_GetDllEntry = 13;
			internal const int idx_GetRefTypeInfo = 14;
			internal const int idx_AddressOfMember = 15;
			internal const int idx_CreateInstance = 16;
			internal const int idx_GetMops = 17;
			internal const int idx_GetContainingTypeLib = 18;
			internal const int idx_ReleaseTypeAttr = 19;
			internal const int idx_ReleaseFuncDesc = 20;
			internal const int idx_ReleaseVarDesc = 21;
		}
	}

	// System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop
	public unsafe static class ITypeComp__System_Private_Interop__Impl
	{
		// StubClass for 'System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop'
		public static partial class StubClass
		{
			// Signature, System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop.Bind, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] short__short, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop *, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.EnumMarshaller] System_Runtime_InteropServices_ComTypes_DESCKIND__System_Private_Interop__DESCKIND__System_Private_Interop, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableStructMarshaller] System_Runtime_InteropServices_ComTypes_BINDPTR__System_Private_Interop__System_Runtime_InteropServices_ComTypes__BINDPTR__System_Private_Interop, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Bind(
						global::System.__ComObject __this, 
						string szName, 
						int lHashVal, 
						short wFlags, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo, 
						out global::System.Runtime.InteropServices.ComTypes.DESCKIND__System_Private_Interop pDescKind, 
						out global::System.Runtime.InteropServices.ComTypes.BINDPTR__System_Private_Interop pBindPtr)
			{
				// Setup
				ushort* unsafe_szName = default(ushort*);
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl** unsafe_ppTInfo = default(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl**);
				global::System.Runtime.InteropServices.ComTypes.DESCKIND__System_Private_Interop unsafe_pDescKind;
				global::System.Runtime.InteropServices.ComTypes.BINDPTR__System_Private_Interop unsafe_pBindPtr;
				int unsafe___return__;
				try
				{
					// Marshalling
					fixed (char* pinned_szName = szName)
					{
						unsafe_szName = (ushort*)pinned_szName;
						unsafe_ppTInfo = null;
						// Call to native method
						unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
											__this, 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeComp,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>"), 
											global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.Vtbl.idx_Bind, 
											unsafe_szName, 
											lHashVal, 
											wFlags, 
											&(unsafe_ppTInfo), 
											&(unsafe_pDescKind), 
											&(unsafe_pBindPtr)
										);
						global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
						pBindPtr = unsafe_pBindPtr;
						pDescKind = unsafe_pDescKind;
						ppTInfo = (global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
											((global::System.IntPtr)unsafe_ppTInfo), 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>")
										);
					}
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTInfo)));
				}
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop.BindType, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop *, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeComp__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeComp__System_Private_Interop *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void BindType(
						global::System.__ComObject __this, 
						string szName, 
						int lHashVal, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				// Setup
				ushort* unsafe_szName = default(ushort*);
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl** unsafe_ppTInfo = default(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl**);
				global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.Vtbl** unsafe_ppTComp = default(global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					fixed (char* pinned_szName = szName)
					{
						unsafe_szName = (ushort*)pinned_szName;
						unsafe_ppTInfo = null;
						unsafe_ppTComp = null;
						// Call to native method
						unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
											__this, 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeComp,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>"), 
											global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.Vtbl.idx_BindType, 
											unsafe_szName, 
											lHashVal, 
											&(unsafe_ppTInfo), 
											&(unsafe_ppTComp)
										);
						global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
						ppTComp = (global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
											((global::System.IntPtr)unsafe_ppTComp), 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeComp,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>")
										);
						ppTInfo = (global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
											((global::System.IntPtr)unsafe_ppTInfo), 
											global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
													"icKeyToken=<KEY>")
										);
					}
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTInfo)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTComp)));
				}
			}
		}

		// DispatchClass for 'System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop.Bind(
						string szName, 
						int lHashVal, 
						short wFlags, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo, 
						out global::System.Runtime.InteropServices.ComTypes.DESCKIND__System_Private_Interop pDescKind, 
						out global::System.Runtime.InteropServices.ComTypes.BINDPTR__System_Private_Interop pBindPtr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.StubClass.Bind(
									this, 
									szName, 
									lHashVal, 
									wFlags, 
									out ppTInfo, 
									out pDescKind, 
									out pBindPtr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop.BindType(
						string szName, 
						int lHashVal, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop__Impl.StubClass.BindType(
									this, 
									szName, 
									lHashVal, 
									out ppTInfo, 
									out ppTComp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Bind = 3;
			internal const int idx_BindType = 4;
		}
	}

	// System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop
	public unsafe static class ITypeLib__System_Private_Interop__Impl
	{
		// StubClass for 'System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop'
		public static partial class StubClass
		{
			// Signature, System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoCount, [fwd] [return] [Mcg.CodeGen.BlittableValueMarshaller] int__int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetTypeInfoCount(global::System.__ComObject __this)
			{
				// Setup
				int unsafe___value;
				// Marshalling
				// Call to native method
				unsafe___value = global::McgInterop.ComCallHelpers.ComCall__int__(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
											"cKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetTypeInfoCount
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
				return unsafe___value;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeInfo(
						global::System.__ComObject __this, 
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTI)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out__ComTypes_ITypeInfo__Private_Interop__<global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop>(
									__this, 
									index, 
									out ppTI, 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetTypeInfo
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoType, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.EnumMarshaller] System_Runtime_InteropServices_ComTypes_TYPEKIND__System_Private_Interop__TYPEKIND__System_Private_Interop, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeInfoType(
						global::System.__ComObject __this, 
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.TYPEKIND__System_Private_Interop pTKind)
			{
				// Setup
				global::System.Runtime.InteropServices.ComTypes.TYPEKIND__System_Private_Interop unsafe_pTKind;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
											"cKeyToken=<KEY>"), 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetTypeInfoType, 
									index, 
									&(unsafe_pTKind)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				pTKind = unsafe_pTKind;
				// Return
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoOfGuid, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeInfoOfGuid(
						global::System.__ComObject __this, 
						ref global::System.Guid guid, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo)
			{
				// Setup
				global::System.Guid unsafe_guid;
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl** unsafe_ppTInfo = default(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_guid = guid;
					unsafe_ppTInfo = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
												"cKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetTypeInfoOfGuid, 
										&(unsafe_guid), 
										&(unsafe_ppTInfo)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					ppTInfo = (global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_ppTInfo), 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
												"icKeyToken=<KEY>")
									);
					guid = unsafe_guid;
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTInfo)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetLibAttr(
						global::System.__ComObject __this, 
						out global::System.IntPtr ppTLibAttr)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_out_IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop>(
									__this, 
									out ppTLibAttr, 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetLibAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetTypeComp(
						global::System.__ComObject __this, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_out__ComTypes_ITypeComp__Private_Interop__<global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop>(
									__this, 
									out ppTComp, 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetTypeComp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void GetDocumentation(
						global::System.__ComObject __this, 
						int index, 
						out string strName, 
						out string strDocString, 
						out int dwHelpContext, 
						out string strHelpFile)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__out_string__out_string__out_int__out_string__<global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop>(
									__this, 
									index, 
									out strName, 
									out strDocString, 
									out dwHelpContext, 
									out strHelpFile, 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_GetDocumentation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.IsName, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.Win32BoolMarshaller] bool__System.Boolean, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsName(
						global::System.__ComObject __this, 
						string szNameBuf, 
						int lHashVal)
			{
				// Setup
				ushort* unsafe_szNameBuf = default(ushort*);
				int unsafe___value__retval;
				bool __value__retval;
				int unsafe___return__;
				// Marshalling
				fixed (char* pinned_szNameBuf = szNameBuf)
				{
					unsafe_szNameBuf = (ushort*)pinned_szNameBuf;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
												"cKeyToken=<KEY>"), 
										global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_IsName, 
										unsafe_szNameBuf, 
										lHashVal, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval != 0;
				}
				// Return
				return __value__retval;
			}

			// Signature, System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.FindName, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.UnicodeStringMarshaller] string__wchar_t *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop * *, [fwd] [out] [Mcg.CodeGen.BlittableArrayMarshaller] rg_int__int *, [fwd] [in] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] short__short, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void FindName(
						global::System.__ComObject __this, 
						string szNameBuf, 
						int lHashVal, 
						global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop[] ppTInfo, 
						int[] rgMemId, 
						ref short pcFound)
			{
				// Setup
				ushort* unsafe_szNameBuf = default(ushort*);
				global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl*** unsafe_ppTInfo = default(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl***);
				int* unsafe_rgMemId;
				short unsafe_pcFound;
				int unsafe___return__;
				try
				{
					// Marshalling
					fixed (char* pinned_szNameBuf = szNameBuf)
					{
						unsafe_szNameBuf = (ushort*)pinned_szNameBuf;
						if (ppTInfo != null)
							unsafe_ppTInfo = (global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(ppTInfo.Length * sizeof(global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop__Impl.Vtbl**))));
						fixed (int* pinned_rgMemId = global::McgInterop.McgCoreHelpers.GetArrayForCompat(rgMemId))
						{
							unsafe_rgMemId = (int*)pinned_rgMemId;
							unsafe_pcFound = pcFound;
							// Call to native method
							unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
												__this, 
												global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeLib,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publi" +
														"cKeyToken=<KEY>"), 
												global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_FindName, 
												unsafe_szNameBuf, 
												lHashVal, 
												unsafe_ppTInfo, 
												unsafe_rgMemId, 
												&(unsafe_pcFound)
											);
							global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
							pcFound = unsafe_pcFound;
						}
						if (ppTInfo != null)
							for (uint mcgIdx = 0; (mcgIdx < ppTInfo.Length); mcgIdx++)
							{
								// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop * ppTInfo
								ppTInfo[mcgIdx] = (global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
													((global::System.IntPtr)unsafe_ppTInfo[mcgIdx]), 
													global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.ComTypes.ITypeInfo,System.Private.Interop, Version=4.0.0.0, Culture=neutral, Publ" +
															"icKeyToken=<KEY>")
												);
							}
					}
					// Return
				}
				finally
				{
					// Cleanup
					if (unsafe_ppTInfo != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < ppTInfo.Length); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] System_Runtime_InteropServices_ComTypes_ITypeInfo__System_Private_Interop__System_Runtime_InteropServices_ComTypes__ITypeInfo__System_Private_Interop * ppTInfo
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_ppTInfo[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_ppTInfo);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ReleaseTLibAttr(
						global::System.__ComObject __this, 
						global::System.IntPtr pTLibAttr)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_void__IntPtr__<global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop>(
									__this, 
									pTLibAttr, 
									global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.Vtbl.idx_ReleaseTLibAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoCount()
			{
				int __retVal = global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetTypeInfoCount(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfo(
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTI)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetTypeInfo(
									this, 
									index, 
									out ppTI
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoType(
						int index, 
						out global::System.Runtime.InteropServices.ComTypes.TYPEKIND__System_Private_Interop pTKind)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetTypeInfoType(
									this, 
									index, 
									out pTKind
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeInfoOfGuid(
						ref global::System.Guid guid, 
						out global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop ppTInfo)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetTypeInfoOfGuid(
									this, 
									ref guid, 
									out ppTInfo
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetLibAttr(out global::System.IntPtr ppTLibAttr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetLibAttr(
									this, 
									out ppTLibAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetTypeComp(out global::System.Runtime.InteropServices.ComTypes.ITypeComp__System_Private_Interop ppTComp)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetTypeComp(
									this, 
									out ppTComp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.GetDocumentation(
						int index, 
						out string strName, 
						out string strDocString, 
						out int dwHelpContext, 
						out string strHelpFile)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.GetDocumentation(
									this, 
									index, 
									out strName, 
									out strDocString, 
									out dwHelpContext, 
									out strHelpFile
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.IsName(
						string szNameBuf, 
						int lHashVal)
			{
				bool __retVal = global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.IsName(
									this, 
									szNameBuf, 
									lHashVal
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.FindName(
						string szNameBuf, 
						int lHashVal, 
						global::System.Runtime.InteropServices.ComTypes.ITypeInfo__System_Private_Interop[] ppTInfo, 
						int[] rgMemId, 
						ref short pcFound)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.FindName(
									this, 
									szNameBuf, 
									lHashVal, 
									ppTInfo, 
									rgMemId, 
									ref pcFound
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop.ReleaseTLibAttr(global::System.IntPtr pTLibAttr)
			{
				global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop__Impl.StubClass.ReleaseTLibAttr(
									this, 
									pTLibAttr
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.ComTypes.ITypeLib__System_Private_Interop))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetTypeInfoCount = 3;
			internal const int idx_GetTypeInfo = 4;
			internal const int idx_GetTypeInfoType = 5;
			internal const int idx_GetTypeInfoOfGuid = 6;
			internal const int idx_GetLibAttr = 7;
			internal const int idx_GetTypeComp = 8;
			internal const int idx_GetDocumentation = 9;
			internal const int idx_IsName = 10;
			internal const int idx_FindName = 11;
			internal const int idx_ReleaseTLibAttr = 12;
		}
	}

	// System.Runtime.InteropServices.ComTypes.BINDPTR__System_Private_Interop
	public unsafe static class BINDPTR__System_Private_Interop__Impl
	{
	}

	// System.Runtime.InteropServices.ComTypes.DISPPARAMS__System_Private_Interop
	public unsafe static class DISPPARAMS__System_Private_Interop__Impl
	{
	}
}

namespace System.Runtime.InteropServices.WindowsRuntime
{
	// System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime
	public unsafe static class IBufferByteAccess__System_Runtime_WindowsRuntime__Impl
	{
		// StubClass for 'System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime'
		public static partial class StubClass
		{
			// Signature, System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime.GetBuffer, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr GetBuffer(global::System.__ComObject __this)
			{
				// Setup
				global::System.IntPtr unsafe___value__retval;
				global::System.IntPtr __value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									global::System.Runtime.InteropServices.TypeOfHelper.RuntimeTypeHandleOf("System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess,System.Runtime.WindowsRuntime, Version=4.0.10.0," +
											" Culture=neutral, PublicKeyToken=b77a5c561934e089"), 
									global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl.idx_GetBuffer, 
									&(unsafe___value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				__value__retval = unsafe___value__retval;
				// Return
				return __value__retval;
			}
		}

		// DispatchClass for 'System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime.GetBuffer()
			{
				global::System.IntPtr __retVal = global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.StubClass.GetBuffer(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// System_Runtime_InteropServices_WindowsRuntime__IBufferByteAccess__System_Runtime_WindowsRuntime
			global::System.IntPtr pfnGetBuffer_System_Runtime_InteropServices_WindowsRuntime__IBufferByteAccess__System_Runtime_WindowsRuntime;
			internal const int idx_GetBuffer = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl.System_Runtime_InteropServices_WindowsRuntime_IBufferByteAccess__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer), "RVA_System_Runtime_InteropServices_WindowsRuntime_IBufferByteAccess__System_Runtime_WindowsRuntime__Impl_Vtbl_s_" +
				"theCcwVtable")]
			public static global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetBuffer_System_Runtime_InteropServices_WindowsRuntime__IBufferByteAccess__System_Runtime_WindowsRuntime = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget156>(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl.GetBuffer__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime.GetBuffer, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_IntPtr____w64 int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetBuffer__STUB(
						global::System.IntPtr pComThis, 
						global::System.IntPtr* unsafe___value__retval)
			{
				// Setup
				global::System.IntPtr __value__retval;
				try
				{
					// Marshalling
					// Call to managed method
					__value__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetBuffer();
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe___value__retval != null)
						(*(unsafe___value__retval)) = __value__retval;
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe___value__retval != null)
						(*(unsafe___value__retval)) = default(global::System.IntPtr);
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForException(hrExcep);
				}
			}

			private static class System_Runtime_InteropServices_WindowsRuntime_IBufferByteAccess__System_Runtime_WindowsRuntime__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.WindowsRuntime.IBufferByteAccess__System_Runtime_WindowsRuntime__Impl.Vtbl), "GetBuffer__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_System_Runtime_InteropServices_WindowsRuntime_IBufferByteAccess__System_Runtime_WindowsRuntime__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}
}

namespace Windows.ApplicationModel
{
	// Windows.ApplicationModel.ISuspendingEventArgs
	public unsafe static class ISuspendingEventArgs__Impl
	{
		// StubClass for 'Windows.ApplicationModel.ISuspendingEventArgs'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.SuspendingOperation get_SuspendingOperation(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.SuspendingOperation __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.ISuspendingEventArgs, global::Windows.ApplicationModel.SuspendingOperation>(
									__this, 
									global::Windows.ApplicationModel.ISuspendingEventArgs__Impl.Vtbl.idx_get_SuspendingOperation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.ISuspendingEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.ISuspendingEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.ISuspendingEventArgs.SuspendingOperation")]
			global::Windows.ApplicationModel.SuspendingOperation global::Windows.ApplicationModel.ISuspendingEventArgs.get_SuspendingOperation()
			{
				global::Windows.ApplicationModel.SuspendingOperation __retVal = global::Windows.ApplicationModel.ISuspendingEventArgs__Impl.StubClass.get_SuspendingOperation(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.ISuspendingEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_SuspendingOperation = 6;
		}
	}

	// Windows.ApplicationModel.ISuspendingOperation
	public unsafe static class ISuspendingOperation__Impl
	{
		// StubClass for 'Windows.ApplicationModel.ISuspendingOperation'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.SuspendingDeferral GetDeferral(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.SuspendingDeferral __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.ISuspendingOperation, global::Windows.ApplicationModel.SuspendingDeferral>(
									__this, 
									global::Windows.ApplicationModel.ISuspendingOperation__Impl.Vtbl.idx_GetDeferral
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.ISuspendingOperation'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingOperation))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.ISuspendingOperation
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.ApplicationModel.SuspendingDeferral global::Windows.ApplicationModel.ISuspendingOperation.GetDeferral()
			{
				global::Windows.ApplicationModel.SuspendingDeferral __retVal = global::Windows.ApplicationModel.ISuspendingOperation__Impl.StubClass.GetDeferral(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.ISuspendingOperation'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingOperation))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetDeferral = 6;
		}
	}

	// Windows.ApplicationModel.ISuspendingDeferral
	public unsafe static class ISuspendingDeferral__Impl
	{
		// StubClass for 'Windows.ApplicationModel.ISuspendingDeferral'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Complete(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.ApplicationModel.ISuspendingDeferral>(
									__this, 
									global::Windows.ApplicationModel.ISuspendingDeferral__Impl.Vtbl.idx_Complete
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.ISuspendingDeferral'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingDeferral))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.ISuspendingDeferral
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.ApplicationModel.ISuspendingDeferral.Complete()
			{
				global::Windows.ApplicationModel.ISuspendingDeferral__Impl.StubClass.Complete(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.ApplicationModel.ISuspendingDeferral'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ISuspendingDeferral))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Complete = 6;
		}
	}

	// Windows.ApplicationModel.ILeavingBackgroundEventArgs
	public unsafe static class ILeavingBackgroundEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.ILeavingBackgroundEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.ILeavingBackgroundEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.IEnteredBackgroundEventArgs
	public unsafe static class IEnteredBackgroundEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.IEnteredBackgroundEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IEnteredBackgroundEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.IPackageStatics
	public unsafe static class IPackageStatics__Impl
	{
		// StubClass for 'Windows.ApplicationModel.IPackageStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Package get_Current(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Package __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.IPackageStatics, global::Windows.ApplicationModel.Package>(
									__this, 
									global::Windows.ApplicationModel.IPackageStatics__Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.IPackageStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackageStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.IPackageStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.IPackageStatics.Current")]
			global::Windows.ApplicationModel.Package global::Windows.ApplicationModel.IPackageStatics.get_Current()
			{
				global::Windows.ApplicationModel.Package __retVal = global::Windows.ApplicationModel.IPackageStatics__Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.IPackageStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackageStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
		}
	}

	// Windows.ApplicationModel.IPackage
	public unsafe static class IPackage__Impl
	{
		// StubClass for 'Windows.ApplicationModel.IPackage'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.StorageFolder get_InstalledLocation(global::System.__ComObject __this)
			{
				global::Windows.Storage.StorageFolder __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.IPackage, global::Windows.Storage.StorageFolder>(
									__this, 
									global::Windows.ApplicationModel.IPackage__Impl.Vtbl.idx_get_InstalledLocation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.IPackage'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackage))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.IPackage
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.IPackage.InstalledLocation")]
			global::Windows.Storage.StorageFolder global::Windows.ApplicationModel.IPackage.get_InstalledLocation()
			{
				global::Windows.Storage.StorageFolder __retVal = global::Windows.ApplicationModel.IPackage__Impl.StubClass.get_InstalledLocation(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.IPackage'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackage))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_InstalledLocation = 7;
		}
	}

	// Windows.ApplicationModel.IPackage2
	public unsafe static class IPackage2__Impl
	{
		// v-table for 'Windows.ApplicationModel.IPackage2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackage2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.IPackage3
	public unsafe static class IPackage3__Impl
	{
		// v-table for 'Windows.ApplicationModel.IPackage3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackage3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.IPackageWithMetadata
	public unsafe static class IPackageWithMetadata__Impl
	{
		// v-table for 'Windows.ApplicationModel.IPackageWithMetadata'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackageWithMetadata))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.IPackage4
	public unsafe static class IPackage4__Impl
	{
		// v-table for 'Windows.ApplicationModel.IPackage4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.IPackage4))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.ApplicationModel.Activation
{
	// Windows.ApplicationModel.Activation.IActivatedEventArgs
	public unsafe static class IActivatedEventArgs__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Activation.IActivatedEventArgs'
		public static partial class StubClass
		{
			// Signature, Windows.ApplicationModel.Activation.IActivatedEventArgs.get_PreviousExecutionState, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_ApplicationModel_Activation_ApplicationExecutionState__Windows_ApplicationModel_Activation__ApplicationExecutionState, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Activation.ApplicationExecutionState get_PreviousExecutionState(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.ApplicationModel.Activation.ApplicationExecutionState unsafe_value__retval;
				global::Windows.ApplicationModel.Activation.ApplicationExecutionState value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.ApplicationModel.Activation.IActivatedEventArgs).TypeHandle, 
									global::Windows.ApplicationModel.Activation.IActivatedEventArgs__Impl.Vtbl.idx_get_PreviousExecutionState, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Activation.IActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IActivatedEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Activation.IActivatedEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Activation.IActivatedEventArgs.PreviousExecutionState")]
			global::Windows.ApplicationModel.Activation.ApplicationExecutionState global::Windows.ApplicationModel.Activation.IActivatedEventArgs.get_PreviousExecutionState()
			{
				global::Windows.ApplicationModel.Activation.ApplicationExecutionState __retVal = global::Windows.ApplicationModel.Activation.IActivatedEventArgs__Impl.StubClass.get_PreviousExecutionState(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Activation.IActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_PreviousExecutionState = 7;
		}
	}

	// Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs
	public unsafe static class ILaunchActivatedEventArgs__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Arguments(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs>(
									__this, 
									global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs__Impl.Vtbl.idx_get_Arguments
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Activation.IActivatedEventArgs.PreviousExecutionState")]
			global::Windows.ApplicationModel.Activation.ApplicationExecutionState global::Windows.ApplicationModel.Activation.IActivatedEventArgs.get_PreviousExecutionState()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.ApplicationModel.Activation.ApplicationExecutionState);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs.Arguments")]
			string global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs.get_Arguments()
			{
				string __retVal = global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs__Impl.StubClass.get_Arguments(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Arguments = 6;
		}
	}

	// Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs
	public unsafe static class IApplicationViewActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs
	public unsafe static class IPrelaunchActivatedEventArgs__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_PrelaunchActivated(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs>(
									__this, 
									global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs__Impl.Vtbl.idx_get_PrelaunchActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Activation.IActivatedEventArgs.PreviousExecutionState")]
			global::Windows.ApplicationModel.Activation.ApplicationExecutionState global::Windows.ApplicationModel.Activation.IActivatedEventArgs.get_PreviousExecutionState()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.ApplicationModel.Activation.ApplicationExecutionState);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs.PrelaunchActivated")]
			bool global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs.get_PrelaunchActivated()
			{
				bool __retVal = global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs__Impl.StubClass.get_PrelaunchActivated(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_PrelaunchActivated = 6;
		}
	}

	// Windows.ApplicationModel.Activation.IViewSwitcherProvider
	public unsafe static class IViewSwitcherProvider__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IViewSwitcherProvider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IViewSwitcherProvider))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2
	public unsafe static class ILaunchActivatedEventArgs2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser
	public unsafe static class IActivatedEventArgsWithUser__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileActivatedEventArgs
	public unsafe static class IFileActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithNeighboringFiles
	public unsafe static class IFileActivatedEventArgsWithNeighboringFiles__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithNeighboringFiles'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithNeighboringFiles))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithCallerPackageFamilyName
	public unsafe static class IFileActivatedEventArgsWithCallerPackageFamilyName__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithCallerPackageFamilyName'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithCallerPackageFamilyName))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.ISearchActivatedEventArgs
	public unsafe static class ISearchActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.ISearchActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ISearchActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.ISearchActivatedEventArgsWithLinguisticDetails
	public unsafe static class ISearchActivatedEventArgsWithLinguisticDetails__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.ISearchActivatedEventArgsWithLinguisticDetails'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ISearchActivatedEventArgsWithLinguisticDetails))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs
	public unsafe static class IShareTargetActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs
	public unsafe static class IFileOpenPickerActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs2
	public unsafe static class IFileOpenPickerActivatedEventArgs2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs
	public unsafe static class IFileSavePickerActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs2
	public unsafe static class IFileSavePickerActivatedEventArgs2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs
	public unsafe static class ICachedFileUpdaterActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs
	public unsafe static class IBackgroundActivatedEventArgs__Impl
	{
		// v-table for 'Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.ApplicationModel.Core
{
	// Windows.ApplicationModel.Core.ICoreApplicationView
	public unsafe static class ICoreApplicationView__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Core.ICoreApplicationView'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Core.CoreWindow get_CoreWindow(global::System.__ComObject __this)
			{
				global::Windows.UI.Core.CoreWindow __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Core.ICoreApplicationView, global::Windows.UI.Core.CoreWindow>(
									__this, 
									global::Windows.ApplicationModel.Core.ICoreApplicationView__Impl.Vtbl.idx_get_CoreWindow
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Core.ICoreApplicationView'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreApplicationView))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Core.ICoreApplicationView
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Core.ICoreApplicationView.CoreWindow")]
			global::Windows.UI.Core.CoreWindow global::Windows.ApplicationModel.Core.ICoreApplicationView.get_CoreWindow()
			{
				global::Windows.UI.Core.CoreWindow __retVal = global::Windows.ApplicationModel.Core.ICoreApplicationView__Impl.StubClass.get_CoreWindow(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Core.ICoreApplicationView'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreApplicationView))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_CoreWindow = 6;
		}
	}

	// Windows.ApplicationModel.Core.ICoreApplicationView2
	public unsafe static class ICoreApplicationView2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Core.ICoreApplicationView2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreApplicationView2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Core.ICoreApplicationView3
	public unsafe static class ICoreApplicationView3__Impl
	{
		// v-table for 'Windows.ApplicationModel.Core.ICoreApplicationView3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreApplicationView3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Core.ICoreImmersiveApplication
	public unsafe static class ICoreImmersiveApplication__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Core.ICoreImmersiveApplication'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Core.CoreApplicationView get_MainView(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Core.CoreApplicationView __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Core.ICoreImmersiveApplication, global::Windows.ApplicationModel.Core.CoreApplicationView>(
									__this, 
									global::Windows.ApplicationModel.Core.ICoreImmersiveApplication__Impl.Vtbl.idx_get_MainView
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Core.ICoreImmersiveApplication'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreImmersiveApplication))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Core.ICoreImmersiveApplication
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Core.ICoreImmersiveApplication.MainView")]
			global::Windows.ApplicationModel.Core.CoreApplicationView global::Windows.ApplicationModel.Core.ICoreImmersiveApplication.get_MainView()
			{
				global::Windows.ApplicationModel.Core.CoreApplicationView __retVal = global::Windows.ApplicationModel.Core.ICoreImmersiveApplication__Impl.StubClass.get_MainView(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Core.ICoreImmersiveApplication'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Core.ICoreImmersiveApplication))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_MainView = 8;
		}
	}
}

namespace Windows.ApplicationModel.Resources.Core
{
	// Windows.ApplicationModel.Resources.Core.IResourceMap
	public unsafe static class IResourceMap__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceMap'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.ResourceCandidate GetValue(
						global::System.__ComObject __this, 
						string resource, 
						global::Windows.ApplicationModel.Resources.Core.ResourceContext context)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceCandidate __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TArg0__TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceMap, global::Windows.ApplicationModel.Resources.Core.ResourceContext, global::Windows.ApplicationModel.Resources.Core.ResourceCandidate>(
									__this, 
									resource, 
									context, 
									global::Windows.ApplicationModel.Resources.Core.IResourceMap__Impl.Vtbl.idx_GetValueForContext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.ResourceMap GetSubtree(
						global::System.__ComObject __this, 
						string reference)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceMap __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceMap, global::Windows.ApplicationModel.Resources.Core.ResourceMap>(
									__this, 
									reference, 
									global::Windows.ApplicationModel.Resources.Core.IResourceMap__Impl.Vtbl.idx_GetSubtree
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceMap'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceMap))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceMap, global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>
		{
			int global::System.Collections.Generic.IReadOnlyCollection<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Count_Get(this);
				}
			}

			global::Windows.ApplicationModel.Resources.Core.NamedResource global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.this[string index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
			}

			global::System.Collections.Generic.IEnumerable<string> global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.IEnumerable<global::Windows.ApplicationModel.Resources.Core.NamedResource> global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.ContainsKey(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IReadOnlyDictionary<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>.TryGetValue(
						string key, 
						out global::Windows.ApplicationModel.Resources.Core.NamedResource value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapViewSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}

			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle
								);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.ApplicationModel.Resources.Core.ResourceCandidate global::Windows.ApplicationModel.Resources.Core.IResourceMap.GetValue(
						string resource, 
						global::Windows.ApplicationModel.Resources.Core.ResourceContext context)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceCandidate __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceMap__Impl.StubClass.GetValue(
									this, 
									resource, 
									context
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.ApplicationModel.Resources.Core.ResourceMap global::Windows.ApplicationModel.Resources.Core.IResourceMap.GetSubtree(string reference)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceMap __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceMap__Impl.StubClass.GetSubtree(
									this, 
									reference
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceMap'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceMap))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetValueForContext = 8;
			internal const int idx_GetSubtree = 9;
		}
	}

	// Windows.ApplicationModel.Resources.Core.INamedResource
	public unsafe static class INamedResource__Impl
	{
		// v-table for 'Windows.ApplicationModel.Resources.Core.INamedResource'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.INamedResource))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceContextStatics2
	public unsafe static class IResourceContextStatics2__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceContextStatics2'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.ResourceContext GetForViewIndependentUse(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceContext __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2, global::Windows.ApplicationModel.Resources.Core.ResourceContext>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2__Impl.Vtbl.idx_GetForViewIndependentUse
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceContextStatics2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.ApplicationModel.Resources.Core.ResourceContext global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2.GetForViewIndependentUse()
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceContext __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2__Impl.StubClass.GetForViewIndependentUse(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceContextStatics2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceContextStatics2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetForViewIndependentUse = 10;
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceContext
	public unsafe static class IResourceContext__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceContext'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Collections.IObservableMap<string, string> get_QualifierValues(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Collections.IObservableMap<string, string> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceContext, global::Windows.Foundation.Collections.IObservableMap<string, string>>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.Vtbl.idx_get_QualifierValues
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IReadOnlyList<string> get_Languages(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IReadOnlyList<string> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceContext, global::System.Collections.Generic.IReadOnlyList<string>>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.Vtbl.idx_get_Languages
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Languages(
						global::System.__ComObject __this, 
						global::System.Collections.Generic.IReadOnlyList<string> languages)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Resources.Core.IResourceContext, global::System.Collections.Generic.IReadOnlyList<string>>(
									__this, 
									languages, 
									global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.Vtbl.idx_put_Languages
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceContext'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceContext))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceContext
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Resources.Core.IResourceContext.QualifierValues")]
			global::Windows.Foundation.Collections.IObservableMap<string, string> global::Windows.ApplicationModel.Resources.Core.IResourceContext.get_QualifierValues()
			{
				global::Windows.Foundation.Collections.IObservableMap<string, string> __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.StubClass.get_QualifierValues(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Resources.Core.IResourceContext.Languages")]
			global::System.Collections.Generic.IReadOnlyList<string> global::Windows.ApplicationModel.Resources.Core.IResourceContext.get_Languages()
			{
				global::System.Collections.Generic.IReadOnlyList<string> __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.StubClass.get_Languages(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.ApplicationModel.Resources.Core.IResourceContext.Languages")]
			void global::Windows.ApplicationModel.Resources.Core.IResourceContext.put_Languages(global::System.Collections.Generic.IReadOnlyList<string> languages)
			{
				global::Windows.ApplicationModel.Resources.Core.IResourceContext__Impl.StubClass.put_Languages(
									this, 
									languages
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceContext'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceContext))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_QualifierValues = 6;
			internal const int idx_get_Languages = 11;
			internal const int idx_put_Languages = 12;
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceCandidate
	public unsafe static class IResourceCandidate__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceCandidate'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_ValueAsString(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.ApplicationModel.Resources.Core.IResourceCandidate>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceCandidate__Impl.Vtbl.idx_get_ValueAsString
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceCandidate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceCandidate))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceCandidate
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Resources.Core.IResourceCandidate.ValueAsString")]
			string global::Windows.ApplicationModel.Resources.Core.IResourceCandidate.get_ValueAsString()
			{
				string __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceCandidate__Impl.StubClass.get_ValueAsString(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceCandidate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceCandidate))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_ValueAsString = 10;
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceCandidate2
	public unsafe static class IResourceCandidate2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceCandidate2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceCandidate2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceManagerStatics
	public unsafe static class IResourceManagerStatics__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceManagerStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.ResourceManager get_Current(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceManager __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics, global::Windows.ApplicationModel.Resources.Core.ResourceManager>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics__Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceManagerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Resources.Core.IResourceManagerStatics.Current")]
			global::Windows.ApplicationModel.Resources.Core.ResourceManager global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics.get_Current()
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceManager __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics__Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceManagerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceManagerStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceManager
	public unsafe static class IResourceManager__Impl
	{
		// StubClass for 'Windows.ApplicationModel.Resources.Core.IResourceManager'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.ResourceMap get_MainResourceMap(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceMap __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.ApplicationModel.Resources.Core.IResourceManager, global::Windows.ApplicationModel.Resources.Core.ResourceMap>(
									__this, 
									global::Windows.ApplicationModel.Resources.Core.IResourceManager__Impl.Vtbl.idx_get_MainResourceMap
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.ApplicationModel.Resources.Core.IResourceManager'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceManager))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.ApplicationModel.Resources.Core.IResourceManager
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.ApplicationModel.Resources.Core.IResourceManager.MainResourceMap")]
			global::Windows.ApplicationModel.Resources.Core.ResourceMap global::Windows.ApplicationModel.Resources.Core.IResourceManager.get_MainResourceMap()
			{
				global::Windows.ApplicationModel.Resources.Core.ResourceMap __retVal = global::Windows.ApplicationModel.Resources.Core.IResourceManager__Impl.StubClass.get_MainResourceMap(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceManager'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceManager))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_MainResourceMap = 6;
		}
	}

	// Windows.ApplicationModel.Resources.Core.IResourceManager2
	public unsafe static class IResourceManager2__Impl
	{
		// v-table for 'Windows.ApplicationModel.Resources.Core.IResourceManager2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.ApplicationModel.Resources.Core.IResourceManager2))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.Devices
{
	// Windows.Devices.DevicesLowLevelContract
	public unsafe static class DevicesLowLevelContract__Impl
	{
	}
}

namespace Windows.Devices.Enumeration
{
	// Windows.Devices.Enumeration.IDeviceInformationStatics
	public unsafe static class IDeviceInformationStatics__Impl
	{
		// StubClass for 'Windows.Devices.Enumeration.IDeviceInformationStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection> FindAllAsync(
						global::System.__ComObject __this, 
						string aqsFilter)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection> __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.Devices.Enumeration.IDeviceInformationStatics, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>>(
									__this, 
									aqsFilter, 
									global::Windows.Devices.Enumeration.IDeviceInformationStatics__Impl.Vtbl.idx_FindAllAsyncAqsFilter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.Enumeration.IDeviceInformationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Enumeration.IDeviceInformationStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Enumeration.IDeviceInformationStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection> global::Windows.Devices.Enumeration.IDeviceInformationStatics.FindAllAsync(string aqsFilter)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection> __retVal = global::Windows.Devices.Enumeration.IDeviceInformationStatics__Impl.StubClass.FindAllAsync(
									this, 
									aqsFilter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Enumeration.IDeviceInformationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Enumeration.IDeviceInformationStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_FindAllAsyncAqsFilter = 10;
		}
	}

	// Windows.Devices.Enumeration.IDeviceInformation
	public unsafe static class IDeviceInformation__Impl
	{
		// StubClass for 'Windows.Devices.Enumeration.IDeviceInformation'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Id(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Devices.Enumeration.IDeviceInformation>(
									__this, 
									global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl.idx_get_Id
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.Enumeration.IDeviceInformation'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Enumeration.IDeviceInformation))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Enumeration.IDeviceInformation
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Devices.Enumeration.IDeviceInformation.Id")]
			string global::Windows.Devices.Enumeration.IDeviceInformation.get_Id()
			{
				string __retVal = global::Windows.Devices.Enumeration.IDeviceInformation__Impl.StubClass.get_Id(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Enumeration.IDeviceInformation'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Enumeration.IDeviceInformation))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Id = 6;
		}
	}

	// Windows.Devices.Enumeration.IDeviceInformation2
	public unsafe static class IDeviceInformation2__Impl
	{
		// v-table for 'Windows.Devices.Enumeration.IDeviceInformation2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Enumeration.IDeviceInformation2))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.Devices.Gpio
{
	// Windows.Devices.Gpio.IGpioControllerStatics
	public unsafe static class IGpioControllerStatics__Impl
	{
		// StubClass for 'Windows.Devices.Gpio.IGpioControllerStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Gpio.GpioController GetDefault(global::System.__ComObject __this)
			{
				global::Windows.Devices.Gpio.GpioController __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Devices.Gpio.IGpioControllerStatics, global::Windows.Devices.Gpio.GpioController>(
									__this, 
									global::Windows.Devices.Gpio.IGpioControllerStatics__Impl.Vtbl.idx_GetDefault
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.Gpio.IGpioControllerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioControllerStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Gpio.IGpioControllerStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Devices.Gpio.GpioController global::Windows.Devices.Gpio.IGpioControllerStatics.GetDefault()
			{
				global::Windows.Devices.Gpio.GpioController __retVal = global::Windows.Devices.Gpio.IGpioControllerStatics__Impl.StubClass.GetDefault(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Gpio.IGpioControllerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioControllerStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetDefault = 6;
		}
	}

	// Windows.Devices.Gpio.IGpioController
	public unsafe static class IGpioController__Impl
	{
		// StubClass for 'Windows.Devices.Gpio.IGpioController'
		public static partial class StubClass
		{
			// Signature, Windows.Devices.Gpio.IGpioController.TryOpenPin, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.WinRTClassMarshaller] Windows_Devices_Gpio_GpioPin__Windows_Devices_Gpio__GpioPin *, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_Devices_Gpio_GpioOpenStatus__Windows_Devices_Gpio__GpioOpenStatus, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool TryOpenPin(
						global::System.__ComObject __this, 
						int pinNumber, 
						global::Windows.Devices.Gpio.GpioSharingMode sharingMode, 
						out global::Windows.Devices.Gpio.GpioPin pin, 
						out global::Windows.Devices.Gpio.GpioOpenStatus openStatus)
			{
				// Setup
				global::Windows.Devices.Gpio.IGpioPin__Impl.Vtbl** unsafe_pin = default(global::Windows.Devices.Gpio.IGpioPin__Impl.Vtbl**);
				global::Windows.Devices.Gpio.GpioOpenStatus unsafe_openStatus;
				bool succeeded__retval;
				sbyte unsafe_succeeded__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_pin = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Devices.Gpio.IGpioController).TypeHandle, 
										global::Windows.Devices.Gpio.IGpioController__Impl.Vtbl.idx_TryOpenPin, 
										pinNumber, 
										((int)sharingMode), 
										&(unsafe_pin), 
										&(unsafe_openStatus), 
										&(unsafe_succeeded__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					succeeded__retval = unsafe_succeeded__retval != 0;
					openStatus = unsafe_openStatus;
					pin = (global::Windows.Devices.Gpio.GpioPin)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_pin), 
										typeof(global::Windows.Devices.Gpio.GpioPin).TypeHandle
									);
					// Return
					return succeeded__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_pin)));
				}
			}
		}

		// DispatchClass for 'Windows.Devices.Gpio.IGpioController'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioController))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Gpio.IGpioController
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Devices.Gpio.IGpioController.TryOpenPin(
						int pinNumber, 
						global::Windows.Devices.Gpio.GpioSharingMode sharingMode, 
						out global::Windows.Devices.Gpio.GpioPin pin, 
						out global::Windows.Devices.Gpio.GpioOpenStatus openStatus)
			{
				bool __retVal = global::Windows.Devices.Gpio.IGpioController__Impl.StubClass.TryOpenPin(
									this, 
									pinNumber, 
									sharingMode, 
									out pin, 
									out openStatus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Gpio.IGpioController'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioController))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_TryOpenPin = 9;
		}
	}

	// Windows.Devices.Gpio.IGpioPin
	public unsafe static class IGpioPin__Impl
	{
		// StubClass for 'Windows.Devices.Gpio.IGpioPin'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void SetDriveMode(
						global::System.__ComObject __this, 
						global::Windows.Devices.Gpio.GpioPinDriveMode value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.Devices.Gpio.IGpioPin>(
									__this, 
									((int)value), 
									global::Windows.Devices.Gpio.IGpioPin__Impl.Vtbl.idx_SetDriveMode
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Write(
						global::System.__ComObject __this, 
						global::Windows.Devices.Gpio.GpioPinValue value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.Devices.Gpio.IGpioPin>(
									__this, 
									((int)value), 
									global::Windows.Devices.Gpio.IGpioPin__Impl.Vtbl.idx_Write
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Devices.Gpio.IGpioPin'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioPin))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Gpio.IGpioPin
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.Gpio.IGpioPin.SetDriveMode(global::Windows.Devices.Gpio.GpioPinDriveMode value)
			{
				global::Windows.Devices.Gpio.IGpioPin__Impl.StubClass.SetDriveMode(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.Gpio.IGpioPin.Write(global::Windows.Devices.Gpio.GpioPinValue value)
			{
				global::Windows.Devices.Gpio.IGpioPin__Impl.StubClass.Write(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Devices.Gpio.IGpioPin'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Gpio.IGpioPin))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_SetDriveMode = 14;
			internal const int idx_Write = 15;
		}
	}
}

namespace Windows.Devices.I2c
{
	// Windows.Devices.I2c.II2cDeviceStatics
	public unsafe static class II2cDeviceStatics__Impl
	{
		// StubClass for 'Windows.Devices.I2c.II2cDeviceStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetDeviceSelector(
						global::System.__ComObject __this, 
						string friendlyName)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__string__<global::Windows.Devices.I2c.II2cDeviceStatics>(
									__this, 
									friendlyName, 
									global::Windows.Devices.I2c.II2cDeviceStatics__Impl.Vtbl.idx_GetDeviceSelectorFromFriendlyName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice> FromIdAsync(
						global::System.__ComObject __this, 
						string deviceId, 
						global::Windows.Devices.I2c.I2cConnectionSettings settings)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice> __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TArg0__TResult__<global::Windows.Devices.I2c.II2cDeviceStatics, global::Windows.Devices.I2c.I2cConnectionSettings, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>>(
									__this, 
									deviceId, 
									settings, 
									global::Windows.Devices.I2c.II2cDeviceStatics__Impl.Vtbl.idx_FromIdAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.I2c.II2cDeviceStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cDeviceStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.I2c.II2cDeviceStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.Devices.I2c.II2cDeviceStatics.GetDeviceSelector(string friendlyName)
			{
				string __retVal = global::Windows.Devices.I2c.II2cDeviceStatics__Impl.StubClass.GetDeviceSelector(
									this, 
									friendlyName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice> global::Windows.Devices.I2c.II2cDeviceStatics.FromIdAsync(
						string deviceId, 
						global::Windows.Devices.I2c.I2cConnectionSettings settings)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice> __retVal = global::Windows.Devices.I2c.II2cDeviceStatics__Impl.StubClass.FromIdAsync(
									this, 
									deviceId, 
									settings
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.I2c.II2cDeviceStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cDeviceStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetDeviceSelectorFromFriendlyName = 7;
			internal const int idx_FromIdAsync = 8;
		}
	}

	// Windows.Devices.I2c.II2cConnectionSettingsFactory
	public unsafe static class II2cConnectionSettingsFactory__Impl
	{
		// StubClass for 'Windows.Devices.I2c.II2cConnectionSettingsFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr Create(
						global::System.__ComObject __this, 
						int slaveAddress)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_int__IntPtr__<global::Windows.Devices.I2c.II2cConnectionSettingsFactory>(
									__this, 
									slaveAddress, 
									global::Windows.Devices.I2c.II2cConnectionSettingsFactory__Impl.Vtbl.idx_Create
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.I2c.II2cConnectionSettingsFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cConnectionSettingsFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.I2c.II2cConnectionSettingsFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.Devices.I2c.II2cConnectionSettingsFactory.Create(int slaveAddress)
			{
				global::System.IntPtr __retVal = global::Windows.Devices.I2c.II2cConnectionSettingsFactory__Impl.StubClass.Create(
									this, 
									slaveAddress
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.I2c.II2cConnectionSettingsFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cConnectionSettingsFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Create = 6;
		}
	}

	// Windows.Devices.I2c.II2cConnectionSettings
	public unsafe static class II2cConnectionSettings__Impl
	{
		// StubClass for 'Windows.Devices.I2c.II2cConnectionSettings'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_BusSpeed(
						global::System.__ComObject __this, 
						global::Windows.Devices.I2c.I2cBusSpeed value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.Devices.I2c.II2cConnectionSettings>(
									__this, 
									((int)value), 
									global::Windows.Devices.I2c.II2cConnectionSettings__Impl.Vtbl.idx_put_BusSpeed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Devices.I2c.II2cConnectionSettings'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cConnectionSettings))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.I2c.II2cConnectionSettings
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Devices.I2c.II2cConnectionSettings.BusSpeed")]
			void global::Windows.Devices.I2c.II2cConnectionSettings.put_BusSpeed(global::Windows.Devices.I2c.I2cBusSpeed value)
			{
				global::Windows.Devices.I2c.II2cConnectionSettings__Impl.StubClass.put_BusSpeed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Devices.I2c.II2cConnectionSettings'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cConnectionSettings))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_BusSpeed = 9;
		}
	}

	// Windows.Devices.I2c.II2cDevice
	public unsafe static class II2cDevice__Impl
	{
		// StubClass for 'Windows.Devices.I2c.II2cDevice'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Write(
						global::System.__ComObject __this, 
						byte[] buffer)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_rg_byte__<global::Windows.Devices.I2c.II2cDevice>(
									__this, 
									buffer, 
									global::Windows.Devices.I2c.II2cDevice__Impl.Vtbl.idx_Write
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void WriteRead(
						global::System.__ComObject __this, 
						byte[] writeBuffer, 
						byte[] readBuffer)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_rg_byte__out_rg_byte__<global::Windows.Devices.I2c.II2cDevice>(
									__this, 
									writeBuffer, 
									readBuffer, 
									global::Windows.Devices.I2c.II2cDevice__Impl.Vtbl.idx_WriteRead
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Devices.I2c.II2cDevice'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cDevice))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.I2c.II2cDevice
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.I2c.II2cDevice.Write(byte[] buffer)
			{
				global::Windows.Devices.I2c.II2cDevice__Impl.StubClass.Write(
									this, 
									buffer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.I2c.II2cDevice.WriteRead(
						byte[] writeBuffer, 
						byte[] readBuffer)
			{
				global::Windows.Devices.I2c.II2cDevice__Impl.StubClass.WriteRead(
									this, 
									writeBuffer, 
									readBuffer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Devices.I2c.II2cDevice'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.I2c.II2cDevice))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Write = 8;
			internal const int idx_WriteRead = 12;
		}
	}
}

namespace Windows.Devices.Spi
{
	// Windows.Devices.Spi.ISpiConnectionSettingsFactory
	public unsafe static class ISpiConnectionSettingsFactory__Impl
	{
		// StubClass for 'Windows.Devices.Spi.ISpiConnectionSettingsFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr Create(
						global::System.__ComObject __this, 
						int chipSelectLine)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_int__IntPtr__<global::Windows.Devices.Spi.ISpiConnectionSettingsFactory>(
									__this, 
									chipSelectLine, 
									global::Windows.Devices.Spi.ISpiConnectionSettingsFactory__Impl.Vtbl.idx_Create
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.Spi.ISpiConnectionSettingsFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiConnectionSettingsFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Spi.ISpiConnectionSettingsFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.Devices.Spi.ISpiConnectionSettingsFactory.Create(int chipSelectLine)
			{
				global::System.IntPtr __retVal = global::Windows.Devices.Spi.ISpiConnectionSettingsFactory__Impl.StubClass.Create(
									this, 
									chipSelectLine
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Spi.ISpiConnectionSettingsFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiConnectionSettingsFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Create = 6;
		}
	}

	// Windows.Devices.Spi.ISpiConnectionSettings
	public unsafe static class ISpiConnectionSettings__Impl
	{
		// StubClass for 'Windows.Devices.Spi.ISpiConnectionSettings'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Mode(
						global::System.__ComObject __this, 
						global::Windows.Devices.Spi.SpiMode value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.Devices.Spi.ISpiConnectionSettings>(
									__this, 
									((int)value), 
									global::Windows.Devices.Spi.ISpiConnectionSettings__Impl.Vtbl.idx_put_Mode
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_ClockFrequency(
						global::System.__ComObject __this, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__<global::Windows.Devices.Spi.ISpiConnectionSettings>(
									__this, 
									value, 
									global::Windows.Devices.Spi.ISpiConnectionSettings__Impl.Vtbl.idx_put_ClockFrequency
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Devices.Spi.ISpiConnectionSettings'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiConnectionSettings))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Spi.ISpiConnectionSettings
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Devices.Spi.ISpiConnectionSettings.Mode")]
			void global::Windows.Devices.Spi.ISpiConnectionSettings.put_Mode(global::Windows.Devices.Spi.SpiMode value)
			{
				global::Windows.Devices.Spi.ISpiConnectionSettings__Impl.StubClass.put_Mode(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Devices.Spi.ISpiConnectionSettings.ClockFrequency")]
			void global::Windows.Devices.Spi.ISpiConnectionSettings.put_ClockFrequency(int value)
			{
				global::Windows.Devices.Spi.ISpiConnectionSettings__Impl.StubClass.put_ClockFrequency(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Devices.Spi.ISpiConnectionSettings'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiConnectionSettings))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Mode = 9;
			internal const int idx_put_ClockFrequency = 13;
		}
	}

	// Windows.Devices.Spi.ISpiDeviceStatics
	public unsafe static class ISpiDeviceStatics__Impl
	{
		// StubClass for 'Windows.Devices.Spi.ISpiDeviceStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetDeviceSelector(
						global::System.__ComObject __this, 
						string friendlyName)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__string__<global::Windows.Devices.Spi.ISpiDeviceStatics>(
									__this, 
									friendlyName, 
									global::Windows.Devices.Spi.ISpiDeviceStatics__Impl.Vtbl.idx_GetDeviceSelectorFromFriendlyName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice> FromIdAsync(
						global::System.__ComObject __this, 
						string busId, 
						global::Windows.Devices.Spi.SpiConnectionSettings settings)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice> __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TArg0__TResult__<global::Windows.Devices.Spi.ISpiDeviceStatics, global::Windows.Devices.Spi.SpiConnectionSettings, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>>(
									__this, 
									busId, 
									settings, 
									global::Windows.Devices.Spi.ISpiDeviceStatics__Impl.Vtbl.idx_FromIdAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Devices.Spi.ISpiDeviceStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiDeviceStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Spi.ISpiDeviceStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.Devices.Spi.ISpiDeviceStatics.GetDeviceSelector(string friendlyName)
			{
				string __retVal = global::Windows.Devices.Spi.ISpiDeviceStatics__Impl.StubClass.GetDeviceSelector(
									this, 
									friendlyName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice> global::Windows.Devices.Spi.ISpiDeviceStatics.FromIdAsync(
						string busId, 
						global::Windows.Devices.Spi.SpiConnectionSettings settings)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice> __retVal = global::Windows.Devices.Spi.ISpiDeviceStatics__Impl.StubClass.FromIdAsync(
									this, 
									busId, 
									settings
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Devices.Spi.ISpiDeviceStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiDeviceStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetDeviceSelectorFromFriendlyName = 7;
			internal const int idx_FromIdAsync = 9;
		}
	}

	// Windows.Devices.Spi.ISpiDevice
	public unsafe static class ISpiDevice__Impl
	{
		// StubClass for 'Windows.Devices.Spi.ISpiDevice'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Write(
						global::System.__ComObject __this, 
						byte[] buffer)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_rg_byte__<global::Windows.Devices.Spi.ISpiDevice>(
									__this, 
									buffer, 
									global::Windows.Devices.Spi.ISpiDevice__Impl.Vtbl.idx_Write
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TransferFullDuplex(
						global::System.__ComObject __this, 
						byte[] writeBuffer, 
						byte[] readBuffer)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_rg_byte__out_rg_byte__<global::Windows.Devices.Spi.ISpiDevice>(
									__this, 
									writeBuffer, 
									readBuffer, 
									global::Windows.Devices.Spi.ISpiDevice__Impl.Vtbl.idx_TransferFullDuplex
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Devices.Spi.ISpiDevice'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiDevice))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Devices.Spi.ISpiDevice
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.Spi.ISpiDevice.Write(byte[] buffer)
			{
				global::Windows.Devices.Spi.ISpiDevice__Impl.StubClass.Write(
									this, 
									buffer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Devices.Spi.ISpiDevice.TransferFullDuplex(
						byte[] writeBuffer, 
						byte[] readBuffer)
			{
				global::Windows.Devices.Spi.ISpiDevice__Impl.StubClass.TransferFullDuplex(
									this, 
									writeBuffer, 
									readBuffer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Devices.Spi.ISpiDevice'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Devices.Spi.ISpiDevice))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Write = 8;
			internal const int idx_TransferFullDuplex = 11;
		}
	}
}

namespace Windows.Foundation
{
	// Windows.Foundation.IStringable
	public unsafe static class IStringable__Impl
	{
		// StubClass for 'Windows.Foundation.IStringable'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string ToString(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Foundation.IStringable>(
									__this, 
									global::Windows.Foundation.IStringable__Impl.Vtbl.idx_ToString
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IStringable'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IStringable))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IStringable
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.Foundation.IStringable.ToString()
			{
				string __retVal = global::Windows.Foundation.IStringable__Impl.StubClass.ToString(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IStringable'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IStringable))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.IStringable))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_Foundation__IStringable
			global::System.IntPtr pfnToString_Windows_Foundation__IStringable;
			internal const int idx_ToString = 6;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.IStringable__Impl.Vtbl.Windows_Foundation_IStringable__Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_IStringable__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.IStringable__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.IStringable__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnToString_Windows_Foundation__IStringable = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget2>(global::Windows.Foundation.IStringable__Impl.Vtbl.ToString__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int ToString__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.IStringable>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_string__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_IStringable__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.Foundation.IStringable__Impl.Vtbl), "ToString__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_IStringable__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.DragStartingEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.DragStartingEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.DragStartingEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V__" +
				"_Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget52>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.IDragStartingEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.DropCompletedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.DropCompletedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.DropCompletedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V_" +
				"__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget53>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.IDropCompletedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.ContextRequestedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.Input.ContextRequestedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.ContextRequestedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEve" +
				"ntArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget59>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Input.IContextRequestedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.RoutedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.RoutedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.RoutedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl_" +
				"Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget60>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.IRoutedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayReq" +
				"uestedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget61>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDis" +
				"missedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget62>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.UIElement sender, 
					global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>, global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement,Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEve" +
				"ntArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget63>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IUIElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Input.IAccessKeyInvokedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,Windows.UI.Xaml.DataContextChangedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.FrameworkElement sender, 
					global::Windows.UI.Xaml.DataContextChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>, global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,Windows.UI.Xaml.DataContextChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChanged" +
				"EventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget67>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.IDataContextChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,System.Object>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl
	{
		// Signature, Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,System.Object>.Invoke, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_FrameworkElement__Windows_UI_Xaml__FrameworkElement *, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.FrameworkElement sender, 
					object args)
		{
			// Setup
			global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl** unsafe_sender = default(global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl**);
			global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_args = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
			int unsafe___return__;
			try
			{
				// Marshalling
				unsafe_sender = (global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
									sender, 
									typeof(global::Windows.UI.Xaml.FrameworkElement).TypeHandle
								);
				unsafe_args = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(args);
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object>).TypeHandle, 
									global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl.idx_Invoke, 
									unsafe_sender, 
									unsafe_args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}
			finally
			{
				// Cleanup
				global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_sender)));
				global::System.GC.KeepAlive(sender);
				global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_args)));
			}
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,System.Object>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_object_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_object_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl_Vtbl_s_theC" +
				"cwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_object_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget69>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement,System.Object>.Invoke, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_FrameworkElement__Windows_UI_Xaml__FrameworkElement *, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl** unsafe_sender, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_args)
			{
				// Setup
				global::Windows.UI.Xaml.FrameworkElement sender = default(global::Windows.UI.Xaml.FrameworkElement);
				object args = default(object);
				try
				{
					// Marshalling
					sender = (global::Windows.UI.Xaml.FrameworkElement)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_sender), 
										typeof(global::Windows.UI.Xaml.FrameworkElement).TypeHandle
									);
					args = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_args));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object>>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).Invoke(
										sender, 
										args
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control,Windows.UI.Xaml.Controls.FocusEngagedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.Control sender, 
					global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>, global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control,Windows.UI.Xaml.Controls.FocusEngagedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEnga" +
				"gedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget74>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.IFocusEngagedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control,Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.Control sender, 
					global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>, global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control,Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDise" +
				"ngagedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget75>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.IFocusDisengagedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.TextBox sender, 
					global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>, global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompo" +
				"sitionStartedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget89>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextCompositionStartedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.TextBox sender, 
					global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>, global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompo" +
				"sitionChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget90>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextCompositionChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.TextBox sender, 
					global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>, global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompo" +
				"sitionEndedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget91>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextCompositionEndedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.TextBox sender, 
					global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>, global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_Candidate" +
				"WindowBoundsChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget92>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>
	public unsafe static class TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.Controls.TextBox sender, 
					global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs args)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>, global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>(
								__this, 
								sender, 
								args, 
								global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox,Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl.Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTe" +
				"xtChangingEventArgs_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget93>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl** unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>
	public unsafe static class IAsyncOperation_A_Windows_Devices_I2c_I2cDevice_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Devices_I2c_I2cDevice___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget116>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.I2c.I2cDevice GetResults(global::System.__ComObject __this)
			{
				global::Windows.Devices.I2c.I2cDevice __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>, global::Windows.Devices.I2c.I2cDevice>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_I2c_I2cDevice_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice> global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Devices.I2c.I2cDevice global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>.GetResults()
			{
				global::Windows.Devices.I2c.I2cDevice __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_I2c_I2cDevice_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.I2c.I2cDevice>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.I2c.I2cDevice>, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.I2c.I2cDevice>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_I2c_I2cDevice_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.I2c.I2cDevice>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.IStorageItem>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem>, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.IStorageItem>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>
	public unsafe static class IAsyncOperation_A_Windows_Storage_IStorageItem_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Storage_IStorageItem___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget123>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_IStorageItem_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_IStorageItem_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.IStorageItem GetResults(global::System.__ComObject __this)
			{
				global::Windows.Storage.IStorageItem __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>, global::Windows.Storage.IStorageItem>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_IStorageItem_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_IStorageItem_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem> global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.IStorageItem>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.IStorageItem global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>.GetResults()
			{
				global::Windows.Storage.IStorageItem __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_IStorageItem_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>
	public unsafe static class IAsyncOperation_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Devices_Enumeration_DeviceInformationCollection___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget131>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Enumeration.DeviceInformationCollection GetResults(global::System.__ComObject __this)
			{
				global::Windows.Devices.Enumeration.DeviceInformationCollection __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>, global::Windows.Devices.Enumeration.DeviceInformationCollection>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection> global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Devices.Enumeration.DeviceInformationCollection global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>.GetResults()
			{
				global::Windows.Devices.Enumeration.DeviceInformationCollection __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Enumeration.DeviceInformationCollection>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Enumeration.DeviceInformationCollection>, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Enumeration.DeviceInformationCollection>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Enumeration_DeviceInformationCollection_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Enumeration.DeviceInformationCollection>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>
	public unsafe static class IAsyncOperation_A_Windows_Devices_Spi_SpiDevice_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Devices_Spi_SpiDevice___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget132>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Spi.SpiDevice GetResults(global::System.__ComObject __this)
			{
				global::Windows.Devices.Spi.SpiDevice __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>, global::Windows.Devices.Spi.SpiDevice>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Spi_SpiDevice_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice> global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Devices.Spi.SpiDevice global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>.GetResults()
			{
				global::Windows.Devices.Spi.SpiDevice __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Devices_Spi_SpiDevice_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Spi.SpiDevice>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Devices.Spi.SpiDevice>, global::Windows.Foundation.IAsyncOperation<global::Windows.Devices.Spi.SpiDevice>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Devices_Spi_SpiDevice_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Spi.SpiDevice>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>
	public unsafe static class IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>.put_Progress, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationProgressHandler_2_Windows_Storage_Streams_IBuffer__uint___Windows_Foundation__AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Progress(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget136>(global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_put_Progress, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> get_Progress(global::System.__ComObject __this)
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> __ret = global::McgInterop.ForwardComSharedStubs.Func__AsyncOperationProgressHandler_2_Storage_Streams_IBuffer__uint___<global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>>(
									__this, 
									global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_get_Progress
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationWithProgressCompletedHandler_2_Windows_Storage_Streams_IBuffer__uint___Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget137>(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.Streams.IBuffer GetResults(global::System.__ComObject __this)
			{
				global::Windows.Storage.Streams.IBuffer __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>, global::Windows.Storage.Streams.IBuffer>(
									__this, 
									global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperationWithProgress`2.Progress")]
			void global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>.put_Progress(global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> handler)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.StubClass.put_Progress(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncOperationWithProgress`2.Progress")]
			global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>.get_Progress()
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint> __retVal = global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.StubClass.get_Progress(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperationWithProgress`2.Completed")]
			void global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>.put_Completed(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint> handler)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint> global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.Streams.IBuffer global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>.GetResults()
			{
				global::Windows.Storage.Streams.IBuffer __retVal = global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer,uint>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Progress = 6;
			internal const int idx_get_Progress = 7;
			internal const int idx_put_Completed = 8;
			internal const int idx_get_Completed = 9;
			internal const int idx_GetResults = 10;
		}
	}

	// Windows.Foundation.AsyncOperationProgressHandler<Windows.Storage.Streams.IBuffer,uint>
	public unsafe static class AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> asyncInfo, 
					uint progressInfo)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__uint__<global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>, global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>>(
								__this, 
								asyncInfo, 
								progressInfo, 
								global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationProgressHandler<Windows.Storage.Streams.IBuffer,uint>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_s_th" +
				"eCcwVtable")]
			public static global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget138>(global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl** unsafe_asyncInfo, 
						uint unsafe_progressInfo)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.AsyncOperationProgressHandler<global::Windows.Storage.Streams.IBuffer, uint>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__uint__<global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>>(
									__this, 
									unsafe_asyncInfo, 
									unsafe_progressInfo, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_AsyncOperationProgressHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.AsyncOperationWithProgressCompletedHandler<Windows.Storage.Streams.IBuffer,uint>
	public unsafe static class AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>, global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationWithProgressCompletedHandler<Windows.Storage.Streams.IBuffer,uint>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___I" +
				"mpl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget139>(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl** unsafe_asyncInfo, 
						global::Windows.Foundation.AsyncStatus unsafe_asyncStatus)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<global::Windows.Storage.Streams.IBuffer, uint>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0___AsyncStatus__<global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>>(
									__this, 
									unsafe_asyncInfo, 
									unsafe_asyncStatus, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.IAsyncOperationWithProgress<uint,uint>
	public unsafe static class IAsyncOperationWithProgress_A_uint_j_uint_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperationWithProgress<uint,uint>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperationWithProgress<uint,uint>.put_Progress, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationProgressHandler_2_uint__uint___Windows_Foundation__AsyncOperationProgressHandler_A_uint_j_uint_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Progress(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget140>(global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl.idx_put_Progress, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> get_Progress(global::System.__ComObject __this)
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> __ret = global::McgInterop.ForwardComSharedStubs.Func__AsyncOperationProgressHandler_2_uint__uint___<global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
									__this, 
									global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl.idx_get_Progress
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.IAsyncOperationWithProgress<uint,uint>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationWithProgressCompletedHandler_2_uint__uint___Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget141>(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetResults(global::System.__ComObject __this)
			{
				uint __ret = global::McgInterop.ForwardComSharedStubs.Func_uint__<global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
									__this, 
									global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperationWithProgress<uint,uint>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperationWithProgress`2.Progress")]
			void global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>.put_Progress(global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> handler)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.StubClass.put_Progress(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncOperationWithProgress`2.Progress")]
			global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>.get_Progress()
			{
				global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint> __retVal = global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.StubClass.get_Progress(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperationWithProgress`2.Completed")]
			void global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>.put_Completed(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint> handler)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint> global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>.GetResults()
			{
				uint __retVal = global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperationWithProgress<uint,uint>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Progress = 6;
			internal const int idx_get_Progress = 7;
			internal const int idx_put_Completed = 8;
			internal const int idx_get_Completed = 9;
			internal const int idx_GetResults = 10;
		}
	}

	// Windows.Foundation.AsyncOperationProgressHandler<uint,uint>
	public unsafe static class AsyncOperationProgressHandler_A_uint_j_uint_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> asyncInfo, 
					uint progressInfo)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__uint__<global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>, global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
								__this, 
								asyncInfo, 
								progressInfo, 
								global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationProgressHandler<uint,uint>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__AsyncOperationProgressHandler_A_uint_j_uint_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__AsyncOperationProgressHandler_A_uint_j_uint_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl.Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__AsyncOperationProgressHandler_A_uint_j_uint_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget142>(global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl** unsafe_asyncInfo, 
						uint unsafe_progressInfo)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.AsyncOperationProgressHandler<uint, uint>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__uint__<global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
									__this, 
									unsafe_asyncInfo, 
									unsafe_progressInfo, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.AsyncOperationProgressHandler_A_uint_j_uint_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_AsyncOperationProgressHandler_A_uint_j_uint_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint,uint>
	public unsafe static class AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>, global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint,uint>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl.Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation__AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget143>(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.IAsyncOperationWithProgress_A_uint_j_uint_V___Impl.Vtbl** unsafe_asyncInfo, 
						global::Windows.Foundation.AsyncStatus unsafe_asyncStatus)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler<uint, uint>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0___AsyncStatus__<global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
									__this, 
									unsafe_asyncInfo, 
									unsafe_asyncStatus, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_AsyncOperationWithProgressCompletedHandler_A_uint_j_uint_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.IAsyncOperation<bool>
	public unsafe static class IAsyncOperation_A_bool_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<bool>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<bool>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_bool___Windows_Foundation__AsyncOperationCompletedHandler_A_bool_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<bool> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_bool_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_bool_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_bool_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<bool>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget144>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_bool_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<bool>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_bool_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<bool> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<bool>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool GetResults(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.IAsyncOperation<bool>>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_bool_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<bool>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<bool>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<bool>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<bool>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<bool> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_bool_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<bool> global::Windows.Foundation.IAsyncOperation<bool>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<bool>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.IAsyncOperation<bool>.GetResults()
			{
				bool __retVal = global::Windows.Foundation.IAsyncOperation_A_bool_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<bool>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<bool>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<bool>
	public unsafe static class AsyncOperationCompletedHandler_A_bool_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<bool> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<bool>, global::Windows.Foundation.IAsyncOperation<bool>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_bool_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<bool>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>
	public unsafe static class IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Storage_Streams_IRandomAccessStream___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget145>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.Streams.IRandomAccessStream GetResults(global::System.__ComObject __this)
			{
				global::Windows.Storage.Streams.IRandomAccessStream __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>, global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream> global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.Streams.IRandomAccessStream global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>.GetResults()
			{
				global::Windows.Storage.Streams.IRandomAccessStream __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.Streams.IRandomAccessStream>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.Streams.IRandomAccessStream>, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.Streams.IRandomAccessStream>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>
	public unsafe static class IAsyncOperation_A_Windows_Storage_StorageFile_V___Impl
	{
		// StubClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>.put_Completed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_AsyncOperationCompletedHandler_1_Windows_Storage_StorageFile___Windows_Foundation__AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Completed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile> handler)
			{
				// Setup
				global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl.Vtbl** unsafe_handler = default(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget146>(global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>).TypeHandle, 
										global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_StorageFile_V___Impl.Vtbl.idx_put_Completed, 
										unsafe_handler
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile> get_Completed(global::System.__ComObject __this)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.StorageFile GetResults(global::System.__ComObject __this)
			{
				global::Windows.Storage.StorageFile __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>, global::Windows.Storage.StorageFile>(
									__this, 
									global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_StorageFile_V___Impl.Vtbl.idx_GetResults
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Id")]
			uint global::Windows.Foundation.IAsyncInfo.get_Id()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return 0;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.Status")]
			global::Windows.Foundation.AsyncStatus global::Windows.Foundation.IAsyncInfo.get_Status()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncStatus);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.IAsyncInfo.ErrorCode")]
			global::System.Exception global::Windows.Foundation.IAsyncInfo.get_ErrorCode()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::System.Exception);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Cancel()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.IAsyncInfo.Close()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Foundation.IAsyncOperation`1.Completed")]
			void global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>.put_Completed(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile> handler)
			{
				global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_StorageFile_V___Impl.StubClass.put_Completed(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile> global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>.get_Completed()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.StorageFile global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>.GetResults()
			{
				global::Windows.Storage.StorageFile __retVal = global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_StorageFile_V___Impl.StubClass.GetResults(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Completed = 6;
			internal const int idx_get_Completed = 7;
			internal const int idx_GetResults = 8;
		}
	}

	// Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.StorageFile>
	public unsafe static class AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile> asyncInfo, 
					global::Windows.Foundation.AsyncStatus asyncStatus)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int<global::Windows.Foundation.AsyncOperationCompletedHandler<global::Windows.Storage.StorageFile>, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>>(
								__this, 
								asyncInfo, 
								((int)asyncStatus), 
								global::Windows.Foundation.AsyncOperationCompletedHandler_A_Windows_Storage_StorageFile_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.AsyncOperationCompletedHandler<Windows.Storage.StorageFile>'
		public unsafe partial struct Vtbl
		{
			internal const int idx_Invoke = 3;
		}
	}

	// Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>>
	public unsafe static class IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V_ * *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>[] get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl*** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl***);
				global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>[] __value__retval = default(global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>[]);
				uint unsafe___value__retval_mcgLength = 0;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>>).TypeHandle, 
										global::Windows.Foundation.IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V__V___Impl.Vtbl.idx_get_Value, 
										&(unsafe___value__retval_mcgLength), 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe___value__retval == null)
						__value__retval = null;
					else
					{
						__value__retval = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>[unsafe___value__retval_mcgLength];
						if (__value__retval != null)
							for (uint mcgIdx = 0; (mcgIdx < unsafe___value__retval_mcgLength); mcgIdx++)
							{
								// [fwd] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V_ * __value__retval
								global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
													((global::System.IntPtr)unsafe___value__retval[mcgIdx]), 
													typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>).TypeHandle
												));
								__value__retval[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
							}
					}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe___value__retval != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe___value__retval_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlType_V_ * __value__retval
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe___value__retval);
				}
			}
		}

		// v-table for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlType>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlType>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>>
	public unsafe static class IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_System_Type__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_Windows_UI_Xaml_Interop_TypeName_j_Windows_UI_Xaml_Markup_IXamlType_V_ * *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>[] get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl*** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V___Impl.Vtbl***);
				global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>[] __value__retval = default(global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>[]);
				uint unsafe___value__retval_mcgLength = 0;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>>).TypeHandle, 
										global::Windows.Foundation.IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_System_Type_j_Windows_UI_Xaml_Markup_IXamlType_V__V___Impl.Vtbl.idx_get_Value, 
										&(unsafe___value__retval_mcgLength), 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe___value__retval == null)
						__value__retval = null;
					else
					{
						__value__retval = new global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>[unsafe___value__retval_mcgLength];
						if (__value__retval != null)
							for (uint mcgIdx = 0; (mcgIdx < unsafe___value__retval_mcgLength); mcgIdx++)
							{
								// [fwd] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_System_Type__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_Windows_UI_Xaml_Interop_TypeName_j_Windows_UI_Xaml_Markup_IXamlType_V_ * __value__retval
								global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
													((global::System.IntPtr)unsafe___value__retval[mcgIdx]), 
													typeof(global::Windows.Foundation.Collections.IKeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>).TypeHandle
												));
								__value__retval[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
							}
					}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe___value__retval != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe___value__retval_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_System_Type__Windows_UI_Xaml_Markup_IXamlType___Windows_Foundation_Collections__IKeyValuePair_A_Windows_UI_Xaml_Interop_TypeName_j_Windows_UI_Xaml_Markup_IXamlType_V_ * __value__retval
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe___value__retval);
				}
			}
		}

		// v-table for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<System.Type,Windows.UI.Xaml.Markup.IXamlType>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<global::System.Type, global::Windows.UI.Xaml.Markup.IXamlType>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>>
	public unsafe static class IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlMember___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V_ * *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>[] get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.Vtbl*** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V___Impl.Vtbl***);
				global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>[] __value__retval = default(global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>[]);
				uint unsafe___value__retval_mcgLength = 0;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>>).TypeHandle, 
										global::Windows.Foundation.IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V__V___Impl.Vtbl.idx_get_Value, 
										&(unsafe___value__retval_mcgLength), 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe___value__retval == null)
						__value__retval = null;
					else
					{
						__value__retval = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>[unsafe___value__retval_mcgLength];
						if (__value__retval != null)
							for (uint mcgIdx = 0; (mcgIdx < unsafe___value__retval_mcgLength); mcgIdx++)
							{
								// [fwd] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlMember___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V_ * __value__retval
								global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
													((global::System.IntPtr)unsafe___value__retval[mcgIdx]), 
													typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>).TypeHandle
												));
								__value__retval[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
							}
					}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe___value__retval != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe___value__retval_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_UI_Xaml_Markup_IXamlMember___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_UI_Xaml_Markup_IXamlMember_V_ * __value__retval
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe___value__retval);
				}
			}
		}

		// v-table for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,Windows.UI.Xaml.Markup.IXamlMember>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, global::Windows.UI.Xaml.Markup.IXamlMember>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,System.Object>>
	public unsafe static class IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_System_Object_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,System.Object>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,System.Object>>.get_Value, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_string__object___Windows_Foundation_Collections__IKeyValuePair_A_string_j_object_V_ * *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<string, object>[] get_Value(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_string_j_System_Object_V___Impl.Vtbl*** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_string_j_System_Object_V___Impl.Vtbl***);
				global::System.Collections.Generic.KeyValuePair<string, object>[] __value__retval = default(global::System.Collections.Generic.KeyValuePair<string, object>[]);
				uint unsafe___value__retval_mcgLength = 0;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, object>>).TypeHandle, 
										global::Windows.Foundation.IReferenceArray_A_System_Collections_Generic_KeyValuePair_A_string_j_System_Object_V__V___Impl.Vtbl.idx_get_Value, 
										&(unsafe___value__retval_mcgLength), 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe___value__retval == null)
						__value__retval = null;
					else
					{
						__value__retval = new global::System.Collections.Generic.KeyValuePair<string, object>[unsafe___value__retval_mcgLength];
						if (__value__retval != null)
							for (uint mcgIdx = 0; (mcgIdx < unsafe___value__retval_mcgLength); mcgIdx++)
							{
								// [fwd] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__object___Windows_Foundation_Collections__IKeyValuePair_A_string_j_object_V_ * __value__retval
								global::Windows.Foundation.Collections.IKeyValuePair<string, object> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<string, object>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
													((global::System.IntPtr)unsafe___value__retval[mcgIdx]), 
													typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, object>).TypeHandle
												));
								__value__retval[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<string, object>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
							}
					}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe___value__retval != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe___value__retval_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__object___Windows_Foundation_Collections__IKeyValuePair_A_string_j_object_V_ * __value__retval
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe___value__retval);
				}
			}
		}

		// v-table for 'Windows.Foundation.IReferenceArray<System.Collections.Generic.KeyValuePair<string,System.Object>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.IReferenceArray<global::System.Collections.Generic.KeyValuePair<string, object>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Value = 6;
		}
	}

	// Windows.Foundation.UniversalApiContract
	public unsafe static class UniversalApiContract__Impl
	{
	}

	// Windows.Foundation.FoundationContract
	public unsafe static class FoundationContract__Impl
	{
	}
}

namespace Windows.Foundation.Collections
{
	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeer>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeer get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>, global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeer>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_AutomationPeer__Windows_UI_Xaml_Automation_Peers__AutomationPeer * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeer[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationPeer__Windows_UI_Xaml_Automation_Peers__AutomationPeer * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.AutomationPeer)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationPeer__Windows_UI_Xaml_Automation_Peers__AutomationPeer * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>.GetMany(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeer_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>, global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__AutomationPeerAnnotation * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__AutomationPeerAnnotation * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__AutomationPeerAnnotation * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>.GetMany(global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_AutomationPeerAnnotation_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>
	public unsafe static class IIterator_A_Windows_Foundation_Point_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Point get_Current(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Point __ret = global::McgInterop.ForwardComSharedStubs.Func__Point__<global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.BlittableArrayMarshaller] rg_Windows_Foundation_Point__Windows_Foundation__Point *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.Foundation.Point* unsafe_items;
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				// Marshalling
				if (items != null)
					unsafe_items_mcgLength = (uint)items.Length;
				fixed (global::Windows.Foundation.Point* pinned_items = global::McgInterop.McgCoreHelpers.GetArrayForCompat(items))
				{
					unsafe_items = (global::Windows.Foundation.Point*)pinned_items;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
				}
				// Return
				return __value__retval;
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.Foundation.Point global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>.get_Current()
			{
				global::Windows.Foundation.Point __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>.GetMany(global::Windows.Foundation.Point[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Foundation_Point_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Foundation.Point>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>
	public unsafe static class IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point> get_Current(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>, global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_IEnumerable_1_Windows_Foundation_Point___Windows_Foundation_Collections__IIterable_A_Windows_Foundation_Point_V_ * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::System.Collections.Generic.IEnumerable_A_Windows_Foundation_Point_V___Impl.Vtbl*** unsafe_items = default(global::System.Collections.Generic.IEnumerable_A_Windows_Foundation_Point_V___Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::System.Collections.Generic.IEnumerable_A_Windows_Foundation_Point_V___Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::System.Collections.Generic.IEnumerable_A_Windows_Foundation_Point_V___Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] System_Collections_Generic_IEnumerable_1_Windows_Foundation_Point___Windows_Foundation_Collections__IIterable_A_Windows_Foundation_Point_V_ * items
							items[mcgIdx] = (global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] System_Collections_Generic_IEnumerable_1_Windows_Foundation_Point___Windows_Foundation_Collections__IIterable_A_Windows_Foundation_Point_V_ * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point> global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>.get_Current()
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point> __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>.GetMany(global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.IEnumerable<Windows.Foundation.Point>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>
	public unsafe static class IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>.get_Current, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_object__object___Windows_Foundation_Collections__IKeyValuePair_A_object_j_object_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<object, object> get_Current(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl**);
				global::System.Collections.Generic.KeyValuePair<object, object> __value__retval = default(global::System.Collections.Generic.KeyValuePair<object, object>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.Vtbl.idx_get_Current, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					global::Windows.Foundation.Collections.IKeyValuePair<object, object> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<object, object>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
										((global::System.IntPtr)unsafe___value__retval), 
										typeof(global::Windows.Foundation.Collections.IKeyValuePair<object, object>).TypeHandle
									));
					__value__retval = new global::System.Collections.Generic.KeyValuePair<object, object>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_object__object___Windows_Foundation_Collections__IKeyValuePair_A_object_j_object_V_ * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::System.Collections.Generic.KeyValuePair<object, object>[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl*** unsafe_items = default(global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::System.Collections.Generic.KeyValuePair_A_System_Object_j_System_Object_V___Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_object__object___Windows_Foundation_Collections__IKeyValuePair_A_object_j_object_V_ * items
							global::Windows.Foundation.Collections.IKeyValuePair<object, object> pair_items = ((global::Windows.Foundation.Collections.IKeyValuePair<object, object>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Foundation.Collections.IKeyValuePair<object, object>).TypeHandle
											));
							items[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<object, object>(pair_items.get_Key(), pair_items.get_Value());
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_object__object___Windows_Foundation_Collections__IKeyValuePair_A_object_j_object_V_ * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::System.Collections.Generic.KeyValuePair<object, object> global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>.get_Current()
			{
				global::System.Collections.Generic.KeyValuePair<object, object> __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>.GetMany(global::System.Collections.Generic.KeyValuePair<object, object>[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_System_Object_j_System_Object_V__V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<System.Object,System.Object>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<object, object>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>
	public unsafe static class IIterator_A_Windows_UI_Xaml_UIElement_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.UIElement get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.UIElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>, global::Windows.UI.Xaml.UIElement>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_UIElement__Windows_UI_Xaml__UIElement * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.UIElement[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElement__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElement__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElement__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElement__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_UIElement__Windows_UI_Xaml__UIElement * items
							items[mcgIdx] = (global::Windows.UI.Xaml.UIElement)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.UIElement).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_UIElement__Windows_UI_Xaml__UIElement * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.UIElement global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>.get_Current()
			{
				global::Windows.UI.Xaml.UIElement __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>.GetMany(global::Windows.UI.Xaml.UIElement[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_UIElement_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.UIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Controls.RowDefinition get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Controls.RowDefinition __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>, global::Windows.UI.Xaml.Controls.RowDefinition>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Controls_RowDefinition__Windows_UI_Xaml_Controls__RowDefinition * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.RowDefinition[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Controls_RowDefinition__Windows_UI_Xaml_Controls__RowDefinition * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Controls.RowDefinition)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Controls.RowDefinition).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Controls_RowDefinition__Windows_UI_Xaml_Controls__RowDefinition * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Controls.RowDefinition global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>.get_Current()
			{
				global::Windows.UI.Xaml.Controls.RowDefinition __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>.GetMany(global::Windows.UI.Xaml.Controls.RowDefinition[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_RowDefinition_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.RowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>
	public unsafe static class IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.DependencyObject get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.DependencyObject __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>, global::Windows.UI.Xaml.DependencyObject>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_DependencyObject__Windows_UI_Xaml__DependencyObject * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DependencyObject[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_DependencyObject__Windows_UI_Xaml__DependencyObject * items
							items[mcgIdx] = (global::Windows.UI.Xaml.DependencyObject)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.DependencyObject).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_DependencyObject__Windows_UI_Xaml__DependencyObject * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.DependencyObject global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>.get_Current()
			{
				global::Windows.UI.Xaml.DependencyObject __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>.GetMany(global::Windows.UI.Xaml.DependencyObject[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_DependencyObject_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.DependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IDependencyObject get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IDependencyObject __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>, global::Windows.UI.Xaml.IDependencyObject>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IDependencyObject__Windows_UI_Xaml__IDependencyObject * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IDependencyObject[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IDependencyObject__Windows_UI_Xaml__IDependencyObject * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IDependencyObject)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IDependencyObject).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IDependencyObject__Windows_UI_Xaml__IDependencyObject * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IDependencyObject global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>.get_Current()
			{
				global::Windows.UI.Xaml.IDependencyObject __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>.GetMany(global::Windows.UI.Xaml.IDependencyObject[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject2>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IDependencyObject2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IDependencyObject2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>, global::Windows.UI.Xaml.IDependencyObject2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IDependencyObject2__Windows_UI_Xaml__IDependencyObject2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IDependencyObject2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IDependencyObject2__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IDependencyObject2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IDependencyObject2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IDependencyObject2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IDependencyObject2__Windows_UI_Xaml__IDependencyObject2 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IDependencyObject2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IDependencyObject2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IDependencyObject2__Windows_UI_Xaml__IDependencyObject2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IDependencyObject2 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>.get_Current()
			{
				global::Windows.UI.Xaml.IDependencyObject2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>.GetMany(global::Windows.UI.Xaml.IDependencyObject2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IDependencyObject2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IDependencyObject2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IDependencyObject2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IUIElement get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IUIElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>, global::Windows.UI.Xaml.IUIElement>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IUIElement__Windows_UI_Xaml__IUIElement * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IUIElement[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElement__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElement__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElement__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElement__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement__Windows_UI_Xaml__IUIElement * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IUIElement)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement__Windows_UI_Xaml__IUIElement * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IUIElement global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>.get_Current()
			{
				global::Windows.UI.Xaml.IUIElement __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>.GetMany(global::Windows.UI.Xaml.IUIElement[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElementOverrides>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElementOverrides>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IUIElementOverrides get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IUIElementOverrides __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>, global::Windows.UI.Xaml.IUIElementOverrides>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElementOverrides>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IUIElementOverrides__Windows_UI_Xaml__IUIElementOverrides * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IUIElementOverrides[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElementOverrides__Windows_UI_Xaml__IUIElementOverrides * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IUIElementOverrides)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IUIElementOverrides).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElementOverrides__Windows_UI_Xaml__IUIElementOverrides * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IUIElementOverrides global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>.get_Current()
			{
				global::Windows.UI.Xaml.IUIElementOverrides __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>.GetMany(global::Windows.UI.Xaml.IUIElementOverrides[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElementOverrides_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement2>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IUIElement2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IUIElement2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>, global::Windows.UI.Xaml.IUIElement2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IUIElement2__Windows_UI_Xaml__IUIElement2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IUIElement2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElement2__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElement2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElement2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElement2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement2__Windows_UI_Xaml__IUIElement2 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IUIElement2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IUIElement2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement2__Windows_UI_Xaml__IUIElement2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IUIElement2 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>.get_Current()
			{
				global::Windows.UI.Xaml.IUIElement2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>.GetMany(global::Windows.UI.Xaml.IUIElement2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement3>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement3>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IUIElement3 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IUIElement3 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>, global::Windows.UI.Xaml.IUIElement3>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement3>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IUIElement3__Windows_UI_Xaml__IUIElement3 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IUIElement3[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement3__Windows_UI_Xaml__IUIElement3 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IUIElement3)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IUIElement3).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement3__Windows_UI_Xaml__IUIElement3 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IUIElement3 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>.get_Current()
			{
				global::Windows.UI.Xaml.IUIElement3 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>.GetMany(global::Windows.UI.Xaml.IUIElement3[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement3_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement4>
	public unsafe static class IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement4>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.IUIElement4 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.IUIElement4 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>, global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement4>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_IUIElement4__Windows_UI_Xaml__IUIElement4 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.IUIElement4[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement4__Windows_UI_Xaml__IUIElement4 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.IUIElement4)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_IUIElement4__Windows_UI_Xaml__IUIElement4 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.IUIElement4 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>.get_Current()
			{
				global::Windows.UI.Xaml.IUIElement4 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>.GetMany(global::Windows.UI.Xaml.IUIElement4[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_IUIElement4_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.IUIElement4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.IUIElement4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.IRowDefinition>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.IRowDefinition>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Controls.IRowDefinition get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Controls.IRowDefinition __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>, global::Windows.UI.Xaml.Controls.IRowDefinition>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.IRowDefinition>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Controls_IRowDefinition__Windows_UI_Xaml_Controls__IRowDefinition * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.IRowDefinition[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Controls_IRowDefinition__Windows_UI_Xaml_Controls__IRowDefinition * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Controls.IRowDefinition)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Controls.IRowDefinition).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Controls_IRowDefinition__Windows_UI_Xaml_Controls__IRowDefinition * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Controls.IRowDefinition global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>.get_Current()
			{
				global::Windows.UI.Xaml.Controls.IRowDefinition __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>.GetMany(global::Windows.UI.Xaml.Controls.IRowDefinition[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Controls_IRowDefinition_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.IRowDefinition>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Controls.IRowDefinition>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.Inline get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.Inline __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>, global::Windows.UI.Xaml.Documents.Inline>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_Inline__Windows_UI_Xaml_Documents__Inline * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.Inline[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Documents_Inline__Windows_UI_Xaml_Documents__Inline * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.Inline)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.Inline).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Documents_Inline__Windows_UI_Xaml_Documents__Inline * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.Inline global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.Inline __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>.GetMany(global::Windows.UI.Xaml.Documents.Inline[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_Inline_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.Inline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.TextElement>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.TextElement>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.TextElement get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.TextElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>, global::Windows.UI.Xaml.Documents.TextElement>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.TextElement>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_TextElement__Windows_UI_Xaml_Documents__TextElement * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.TextElement[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Documents_TextElement__Windows_UI_Xaml_Documents__TextElement * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.TextElement)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.TextElement).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Documents_TextElement__Windows_UI_Xaml_Documents__TextElement * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.TextElement global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.TextElement __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>.GetMany(global::Windows.UI.Xaml.Documents.TextElement[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_TextElement_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.TextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.TextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.ITextElement get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.ITextElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>, global::Windows.UI.Xaml.Documents.ITextElement>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_ITextElement__Windows_UI_Xaml_Documents__ITextElement * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.ITextElement[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.ITextElement__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement__Windows_UI_Xaml_Documents__ITextElement * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.ITextElement)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.ITextElement).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement__Windows_UI_Xaml_Documents__ITextElement * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.ITextElement global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.ITextElement __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>.GetMany(global::Windows.UI.Xaml.Documents.ITextElement[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElementOverrides>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.ITextElementOverrides get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.ITextElementOverrides __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>, global::Windows.UI.Xaml.Documents.ITextElementOverrides>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElementOverrides>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_ITextElementOverrides__Windows_UI_Xaml_Documents__ITextElementOverrides * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.ITextElementOverrides[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElementOverrides__Windows_UI_Xaml_Documents__ITextElementOverrides * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.ITextElementOverrides)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.ITextElementOverrides).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElementOverrides__Windows_UI_Xaml_Documents__ITextElementOverrides * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.ITextElementOverrides global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.ITextElementOverrides __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>.GetMany(global::Windows.UI.Xaml.Documents.ITextElementOverrides[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElementOverrides_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElementOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElementOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement2>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.ITextElement2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.ITextElement2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>, global::Windows.UI.Xaml.Documents.ITextElement2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_ITextElement2__Windows_UI_Xaml_Documents__ITextElement2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.ITextElement2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.ITextElement2__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.ITextElement2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.ITextElement2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.ITextElement2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement2__Windows_UI_Xaml_Documents__ITextElement2 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.ITextElement2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.ITextElement2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement2__Windows_UI_Xaml_Documents__ITextElement2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.ITextElement2 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.ITextElement2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>.GetMany(global::Windows.UI.Xaml.Documents.ITextElement2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement3>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement3>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.ITextElement3 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.ITextElement3 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>, global::Windows.UI.Xaml.Documents.ITextElement3>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement3>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_ITextElement3__Windows_UI_Xaml_Documents__ITextElement3 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.ITextElement3[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.ITextElement3__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.ITextElement3__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.ITextElement3__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.ITextElement3__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement3__Windows_UI_Xaml_Documents__ITextElement3 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.ITextElement3)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.ITextElement3).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_ITextElement3__Windows_UI_Xaml_Documents__ITextElement3 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.ITextElement3 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.ITextElement3 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>.GetMany(global::Windows.UI.Xaml.Documents.ITextElement3[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_ITextElement3_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ITextElement3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.ITextElement3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.IInline>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.IInline>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.IInline get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.IInline __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>, global::Windows.UI.Xaml.Documents.IInline>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.IInline>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Documents_IInline__Windows_UI_Xaml_Documents__IInline * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Documents.IInline[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Documents.IInline__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_IInline__Windows_UI_Xaml_Documents__IInline * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Documents.IInline)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Documents.IInline).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Documents_IInline__Windows_UI_Xaml_Documents__IInline * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Documents.IInline global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>.get_Current()
			{
				global::Windows.UI.Xaml.Documents.IInline __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>.GetMany(global::Windows.UI.Xaml.Documents.IInline[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Documents_IInline_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.IInline>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Documents.IInline>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>
	public unsafe static class IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>.get_Current, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__string___Windows_Foundation_Collections__IKeyValuePair_A_string_j_string_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<string, string> get_Current(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl**);
				global::System.Collections.Generic.KeyValuePair<string, string> __value__retval = default(global::System.Collections.Generic.KeyValuePair<string, string>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.Vtbl.idx_get_Current, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					global::Windows.Foundation.Collections.IKeyValuePair<string, string> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<string, string>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
										((global::System.IntPtr)unsafe___value__retval), 
										typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, string>).TypeHandle
									));
					__value__retval = new global::System.Collections.Generic.KeyValuePair<string, string>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_string__string___Windows_Foundation_Collections__IKeyValuePair_A_string_j_string_V_ * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::System.Collections.Generic.KeyValuePair<string, string>[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl*** unsafe_items = default(global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::System.Collections.Generic.KeyValuePair_A_string_j_string_V___Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__string___Windows_Foundation_Collections__IKeyValuePair_A_string_j_string_V_ * items
							global::Windows.Foundation.Collections.IKeyValuePair<string, string> pair_items = ((global::Windows.Foundation.Collections.IKeyValuePair<string, string>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, string>).TypeHandle
											));
							items[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<string, string>(pair_items.get_Key(), pair_items.get_Value());
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__string___Windows_Foundation_Collections__IKeyValuePair_A_string_j_string_V_ * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::System.Collections.Generic.KeyValuePair<string, string> global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>.get_Current()
			{
				global::System.Collections.Generic.KeyValuePair<string, string> __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>.GetMany(global::System.Collections.Generic.KeyValuePair<string, string>[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_string_V__V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,string>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, string>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IMapChangedEventArgs<string>
	public unsafe static class IMapChangedEventArgs_A_string_V___Impl
	{
		// v-table for 'Windows.Foundation.Collections.IMapChangedEventArgs<string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IMapChangedEventArgs<string>))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Foundation.Collections.MapChangedEventHandler<string,string>
	public unsafe static class MapChangedEventHandler_A_string_j_string_V___Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.Collections.IObservableMap<string, string> sender, 
					global::Windows.Foundation.Collections.IMapChangedEventArgs<string> @event)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.Collections.MapChangedEventHandler<string, string>, global::Windows.Foundation.Collections.IObservableMap<string, string>, global::Windows.Foundation.Collections.IMapChangedEventArgs<string>>(
								__this, 
								sender, 
								@event, 
								global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.Foundation.Collections.MapChangedEventHandler<string,string>'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Foundation.Collections.MapChangedEventHandler<string, string>))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_Foundation_Collections__MapChangedEventHandler_A_string_j_string_V_
			global::System.IntPtr pfnInvoke_Windows_Foundation_Collections__MapChangedEventHandler_A_string_j_string_V_;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl.Windows_Foundation_Collections_MapChangedEventHandler_A_string_j_string_V___Impl_Vtbl_McgRvaContainer), "RVA_Windows_Foundation_Collections_MapChangedEventHandler_A_string_j_string_V___Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_Foundation_Collections__MapChangedEventHandler_A_string_j_string_V_ = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget117>(global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.Collections.IObservableMap_A_string_j_string_V___Impl.Vtbl** unsafe_sender, 
						global::Windows.Foundation.Collections.IMapChangedEventArgs_A_string_V___Impl.Vtbl** unsafe_event)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Foundation.Collections.MapChangedEventHandler<string, string>>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__TArg1__<global::Windows.Foundation.Collections.IObservableMap<string, string>, global::Windows.Foundation.Collections.IMapChangedEventArgs<string>>(
									__this, 
									unsafe_sender, 
									unsafe_event, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Foundation_Collections_MapChangedEventHandler_A_string_j_string_V___Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Foundation_Collections_MapChangedEventHandler_A_string_j_string_V___Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Foundation.Collections.IObservableMap<string,string>
	public unsafe static class IObservableMap_A_string_j_string_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IObservableMap<string,string>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Collections.IObservableMap<string,string>.add_MapChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_Collections_MapChangedEventHandler_2_string__string___Windows_Foundation_Collections__MapChangedEventHandler_A_string_j_string_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_MapChanged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Collections.MapChangedEventHandler<string, string> vhnd)
			{
				// Setup
				global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl** unsafe_vhnd = default(global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe___value__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_vhnd = (global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										vhnd, 
										typeof(global::Windows.Foundation.Collections.MapChangedEventHandler<string, string>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget118>(global::Windows.Foundation.Collections.MapChangedEventHandler_A_string_j_string_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IObservableMap<string, string>).TypeHandle, 
										global::Windows.Foundation.Collections.IObservableMap_A_string_j_string_V___Impl.Vtbl.idx_add_MapChanged, 
										unsafe_vhnd, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_vhnd)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_MapChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.Foundation.Collections.IObservableMap<string, string>>(
									__this, 
									token, 
									global::Windows.Foundation.Collections.IObservableMap_A_string_j_string_V___Impl.Vtbl.idx_remove_MapChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IObservableMap<string,string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IObservableMap<string, string>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IObservableMap<string, string>, global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>
		{
			int global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Count
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Count(this);
				}
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.IsReadOnly
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.IsReadOnly(this);
				}
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Add(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Clear()
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Clear(this);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Contains(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Contains(
									this, 
									item
								);
			}

			void global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.CopyTo(
						global::System.Collections.Generic.KeyValuePair<string, string>[] array, 
						int arrayindex)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.CopyTo(
									this, 
									array, 
									arrayindex
								);
			}

			bool global::System.Collections.Generic.ICollection<global::System.Collections.Generic.KeyValuePair<string, string>>.Remove(global::System.Collections.Generic.KeyValuePair<string, string> item)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									item
								);
			}

			string global::System.Collections.Generic.IDictionary<string, string>.this[string index]
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Get(
										this, 
										index
									);
				}
				set
				{
					global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Indexer_Set(
										this, 
										index, 
										value
									);
				}
			}

			global::System.Collections.Generic.ICollection<string> global::System.Collections.Generic.IDictionary<string, string>.Keys
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Keys(this);
				}
			}

			global::System.Collections.Generic.ICollection<string> global::System.Collections.Generic.IDictionary<string, string>.Values
			{
				get
				{
					return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Values(this);
				}
			}

			void global::System.Collections.Generic.IDictionary<string, string>.Add(
						string key, 
						string value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Add(
									this, 
									key, 
									value
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.ContainsKey(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.ContainsKey(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.Remove(string key)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.Remove(
									this, 
									key
								);
			}

			bool global::System.Collections.Generic.IDictionary<string, string>.TryGetValue(
						string key, 
						out string value)
			{
				return global::System.Runtime.InteropServices.WindowsRuntime.IMapSharedReferenceTypesRCWAdapter.TryGetValue(
									this, 
									key, 
									out value
								);
			}

			global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>> global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>.GetEnumerator()
			{
				return (global::System.Collections.Generic.IEnumerator<global::System.Collections.Generic.KeyValuePair<string, string>>)global::McgInterop.McgHelpers.GetGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}

			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return global::McgInterop.McgHelpers.GetNonGenericEnumerator(
									this, 
									typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.KeyValuePair<string, string>>).TypeHandle
								);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.Foundation.Collections.IObservableMap`2.MapChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.Foundation.Collections.IObservableMap<string, string>.add_MapChanged(global::Windows.Foundation.Collections.MapChangedEventHandler<string, string> vhnd)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.Foundation.Collections.IObservableMap_A_string_j_string_V___Impl.StubClass.add_MapChanged(
									this, 
									vhnd
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.Foundation.Collections.IObservableMap`2.MapChanged")]
			void global::Windows.Foundation.Collections.IObservableMap<string, string>.remove_MapChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.Foundation.Collections.IObservableMap_A_string_j_string_V___Impl.StubClass.remove_MapChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Foundation.Collections.IObservableMap<string,string>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IObservableMap<string, string>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_MapChanged = 6;
			internal const int idx_remove_MapChanged = 7;
		}
	}

	// Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>
	public unsafe static class IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>.get_Current, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_ApplicationModel_Resources_Core_NamedResource___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> get_Current(global::System.__ComObject __this)
			{
				// Setup
				global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl** unsafe___value__retval = default(global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl**);
				global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> __value__retval = default(global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe___value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.Vtbl.idx_get_Current, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> pair___value__retval = ((global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
										((global::System.IntPtr)unsafe___value__retval), 
										typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle
									));
					__value__retval = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>(pair___value__retval.get_Key(), pair___value__retval.get_Value());
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe___value__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_System_Collections_Generic_KeyValuePair_2_string__Windows_ApplicationModel_Resources_Core_NamedResource___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V_ * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl*** unsafe_items = default(global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::System.Collections.Generic.KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_ApplicationModel_Resources_Core_NamedResource___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V_ * items
							global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> pair_items = ((global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Foundation.Collections.IKeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle
											));
							items[mcgIdx] = new global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>(pair_items.get_Key(), pair_items.get_Value());
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTKeyValuePairMarshaller] System_Collections_Generic_KeyValuePair_2_string__Windows_ApplicationModel_Resources_Core_NamedResource___Windows_Foundation_Collections__IKeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V_ * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.get_Current()
			{
				global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource> __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>.GetMany(global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_System_Collections_Generic_KeyValuePair_A_string_j_Windows_ApplicationModel_Resources_Core_NamedResource_V__V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<System.Collections.Generic.KeyValuePair<string,Windows.ApplicationModel.Resources.Core.NamedResource>>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::System.Collections.Generic.KeyValuePair<string, global::Windows.ApplicationModel.Resources.Core.NamedResource>>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>
	public unsafe static class IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Enumeration.DeviceInformation get_Current(global::System.__ComObject __this)
			{
				global::Windows.Devices.Enumeration.DeviceInformation __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>, global::Windows.Devices.Enumeration.DeviceInformation>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_Devices_Enumeration_DeviceInformation__Windows_Devices_Enumeration__DeviceInformation * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.Devices.Enumeration.DeviceInformation[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl*** unsafe_items = default(global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_Devices_Enumeration_DeviceInformation__Windows_Devices_Enumeration__DeviceInformation * items
							items[mcgIdx] = (global::Windows.Devices.Enumeration.DeviceInformation)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Devices.Enumeration.DeviceInformation).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_Devices_Enumeration_DeviceInformation__Windows_Devices_Enumeration__DeviceInformation * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.Devices.Enumeration.DeviceInformation global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>.get_Current()
			{
				global::Windows.Devices.Enumeration.DeviceInformation __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>.GetMany(global::Windows.Devices.Enumeration.DeviceInformation[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_DeviceInformation_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.DeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.NamedResource>
	public unsafe static class IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.NamedResource>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.NamedResource get_Current(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.NamedResource __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>, global::Windows.ApplicationModel.Resources.Core.NamedResource>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.NamedResource>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_ApplicationModel_Resources_Core_NamedResource__Windows_ApplicationModel_Resources_Core__NamedResource * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Resources.Core.NamedResource[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl*** unsafe_items = default(global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_ApplicationModel_Resources_Core_NamedResource__Windows_ApplicationModel_Resources_Core__NamedResource * items
							items[mcgIdx] = (global::Windows.ApplicationModel.Resources.Core.NamedResource)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.ApplicationModel.Resources.Core.NamedResource).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.WinRTClassMarshaller] Windows_ApplicationModel_Resources_Core_NamedResource__Windows_ApplicationModel_Resources_Core__NamedResource * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.ApplicationModel.Resources.Core.NamedResource global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>.get_Current()
			{
				global::Windows.ApplicationModel.Resources.Core.NamedResource __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>.GetMany(global::Windows.ApplicationModel.Resources.Core.NamedResource[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_NamedResource_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.NamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.NamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.INamedResource>
	public unsafe static class IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.INamedResource>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.ApplicationModel.Resources.Core.INamedResource get_Current(global::System.__ComObject __this)
			{
				global::Windows.ApplicationModel.Resources.Core.INamedResource __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>, global::Windows.ApplicationModel.Resources.Core.INamedResource>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.INamedResource>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_ApplicationModel_Resources_Core_INamedResource__Windows_ApplicationModel_Resources_Core__INamedResource * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Resources.Core.INamedResource[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl*** unsafe_items = default(global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.ApplicationModel.Resources.Core.INamedResource__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_ApplicationModel_Resources_Core_INamedResource__Windows_ApplicationModel_Resources_Core__INamedResource * items
							items[mcgIdx] = (global::Windows.ApplicationModel.Resources.Core.INamedResource)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.ApplicationModel.Resources.Core.INamedResource).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_ApplicationModel_Resources_Core_INamedResource__Windows_ApplicationModel_Resources_Core__INamedResource * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.INamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.ApplicationModel.Resources.Core.INamedResource global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>.get_Current()
			{
				global::Windows.ApplicationModel.Resources.Core.INamedResource __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>.GetMany(global::Windows.ApplicationModel.Resources.Core.INamedResource[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_ApplicationModel_Resources_Core_INamedResource_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.INamedResource>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.ApplicationModel.Resources.Core.INamedResource>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeer__Windows_UI_Xaml_Automation_Peers__IAutomationPeer * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer__Windows_UI_Xaml_Automation_Peers__IAutomationPeer * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer__Windows_UI_Xaml_Automation_Peers__IAutomationPeer * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected__Windows_UI_Xaml_Automation_Peers__IAutomationPeerProtected * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected__Windows_UI_Xaml_Automation_Peers__IAutomationPeerProtected * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected__Windows_UI_Xaml_Automation_Peers__IAutomationPeerProtected * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerProtected_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2__Windows_UI_Xaml_Automation_Peers__IAutomationPeer2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer2__Windows_UI_Xaml_Automation_Peers__IAutomationPeer2 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer2__Windows_UI_Xaml_Automation_Peers__IAutomationPeer2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides2 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3__Windows_UI_Xaml_Automation_Peers__IAutomationPeer3 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer3__Windows_UI_Xaml_Automation_Peers__IAutomationPeer3 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer3__Windows_UI_Xaml_Automation_Peers__IAutomationPeer3 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer3_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides3 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides3 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides3 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides3_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4__Windows_UI_Xaml_Automation_Peers__IAutomationPeer4 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer4__Windows_UI_Xaml_Automation_Peers__IAutomationPeer4 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer4__Windows_UI_Xaml_Automation_Peers__IAutomationPeer4 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer4_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides4 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides4 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides4 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides4_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5__Windows_UI_Xaml_Automation_Peers__IAutomationPeer5 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer5__Windows_UI_Xaml_Automation_Peers__IAutomationPeer5 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeer5__Windows_UI_Xaml_Automation_Peers__IAutomationPeer5 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeer5_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5 get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides5 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides5 * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5__Windows_UI_Xaml_Automation_Peers__IAutomationPeerOverrides5 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5 global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerOverrides5_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>
	public unsafe static class IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__IAutomationPeerAnnotation * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl*** unsafe_items = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__IAutomationPeerAnnotation * items
							items[mcgIdx] = (global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation__Windows_UI_Xaml_Automation_Peers__IAutomationPeerAnnotation * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.get_Current()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>.GetMany(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_UI_Xaml_Automation_Peers_IAutomationPeerAnnotation_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation>
	public unsafe static class IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Enumeration.IDeviceInformation get_Current(global::System.__ComObject __this)
			{
				global::Windows.Devices.Enumeration.IDeviceInformation __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>, global::Windows.Devices.Enumeration.IDeviceInformation>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_Devices_Enumeration_IDeviceInformation__Windows_Devices_Enumeration__IDeviceInformation * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.Devices.Enumeration.IDeviceInformation[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl*** unsafe_items = default(global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.Devices.Enumeration.IDeviceInformation__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Devices_Enumeration_IDeviceInformation__Windows_Devices_Enumeration__IDeviceInformation * items
							items[mcgIdx] = (global::Windows.Devices.Enumeration.IDeviceInformation)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Devices.Enumeration.IDeviceInformation).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Devices_Enumeration_IDeviceInformation__Windows_Devices_Enumeration__IDeviceInformation * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.Devices.Enumeration.IDeviceInformation global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>.get_Current()
			{
				global::Windows.Devices.Enumeration.IDeviceInformation __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>.GetMany(global::Windows.Devices.Enumeration.IDeviceInformation[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}

	// Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation2>
	public unsafe static class IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl
	{
		// StubClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation2>'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Devices.Enumeration.IDeviceInformation2 get_Current(global::System.__ComObject __this)
			{
				global::Windows.Devices.Enumeration.IDeviceInformation2 __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>, global::Windows.Devices.Enumeration.IDeviceInformation2>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasCurrent(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.Vtbl.idx_get_HasCurrent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool MoveNext(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>>(
									__this, 
									global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.Vtbl.idx_MoveNext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation2>.GetMany, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [Mcg.CodeGen.ArrayMarshaller] rg_Windows_Devices_Enumeration_IDeviceInformation2__Windows_Devices_Enumeration__IDeviceInformation2 * *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint GetMany(
						global::System.__ComObject __this, 
						global::Windows.Devices.Enumeration.IDeviceInformation2[] items)
			{
				// Setup
				uint unsafe_items_mcgLength = 0;
				global::Windows.Devices.Enumeration.IDeviceInformation2__Impl.Vtbl*** unsafe_items = default(global::Windows.Devices.Enumeration.IDeviceInformation2__Impl.Vtbl***);
				uint unsafe___value__retval;
				uint __value__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					if (items != null)
						unsafe_items_mcgLength = (uint)items.Length;
					if (items != null)
						unsafe_items = (global::Windows.Devices.Enumeration.IDeviceInformation2__Impl.Vtbl***)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked(unsafe_items_mcgLength * sizeof(global::Windows.Devices.Enumeration.IDeviceInformation2__Impl.Vtbl**))));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>).TypeHandle, 
										global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.Vtbl.idx_GetMany, 
										unsafe_items_mcgLength, 
										unsafe_items, 
										&(unsafe___value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					__value__retval = unsafe___value__retval;
					if (items != null)
						for (uint mcgIdx = 0; (mcgIdx < unsafe_items_mcgLength); mcgIdx++)
						{
							// [fwd] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Devices_Enumeration_IDeviceInformation2__Windows_Devices_Enumeration__IDeviceInformation2 * items
							items[mcgIdx] = (global::Windows.Devices.Enumeration.IDeviceInformation2)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
												((global::System.IntPtr)unsafe_items[mcgIdx]), 
												typeof(global::Windows.Devices.Enumeration.IDeviceInformation2).TypeHandle
											);
						}
					// Return
					return __value__retval;
				}
				finally
				{
					// Cleanup
					if (unsafe_items != null)
						for (uint mcgIdx_1 = 0; (mcgIdx_1 < unsafe_items_mcgLength); mcgIdx_1++)
						{
							// [fwd] [in] [out] [optional] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Devices_Enumeration_IDeviceInformation2__Windows_Devices_Enumeration__IDeviceInformation2 * items
							global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_items[mcgIdx_1])));
						}
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_items);
				}
			}
		}

		// DispatchClass for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.Current")]
			global::Windows.Devices.Enumeration.IDeviceInformation2 global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>.get_Current()
			{
				global::Windows.Devices.Enumeration.IDeviceInformation2 __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Collections.IIterator`1.HasCurrent")]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>.get_HasCurrent()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.StubClass.get_HasCurrent(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>.MoveNext()
			{
				bool __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.StubClass.MoveNext(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			uint global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>.GetMany(global::Windows.Devices.Enumeration.IDeviceInformation2[] items)
			{
				uint __retVal = global::Windows.Foundation.Collections.IIterator_A_Windows_Devices_Enumeration_IDeviceInformation2_V___Impl.StubClass.GetMany(
									this, 
									items
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.IDeviceInformation2>'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Collections.IIterator<global::Windows.Devices.Enumeration.IDeviceInformation2>))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
			internal const int idx_get_HasCurrent = 7;
			internal const int idx_MoveNext = 8;
			internal const int idx_GetMany = 9;
		}
	}
}

namespace Windows.Foundation.Diagnostics
{
	// Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs
	public unsafe static class ITracingStatusChangedEventArgs__Impl
	{
		// StubClass for 'Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_Enabled(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs>(
									__this, 
									global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs__Impl.Vtbl.idx_get_Enabled
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs.Enabled")]
			bool global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs.get_Enabled()
			{
				bool __retVal = global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs__Impl.StubClass.get_Enabled(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Enabled = 6;
		}
	}

	// Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics
	public unsafe static class IAsyncCausalityTracerStatics__Impl
	{
		// StubClass for 'Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceOperationCreation, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_Guid__System.Guid, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] ulong__unsigned __int64, [fwd] [in] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] ulong__unsigned __int64, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TraceOperationCreation(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						string operationName, 
						ulong relatedContext)
			{
				// Setup
				global::System.Runtime.InteropServices.HSTRING unsafe_operationName = default(global::System.Runtime.InteropServices.HSTRING);
				int unsafe___return__;
				// Marshalling
				fixed (char* pBuffer_operationName = operationName)
				{
					global::System.Runtime.InteropServices.HSTRING_HEADER hstring_header_operationName;
					global::System.Runtime.InteropServices.McgMarshal.StringToHStringReference(pBuffer_operationName, operationName, &(hstring_header_operationName), &(unsafe_operationName));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics).TypeHandle, 
										global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_TraceOperationCreation, 
										((int)traceLevel), 
										((int)source), 
										platformId, 
										operationId, 
										unsafe_operationName, 
										relatedContext
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				}
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TraceOperationCompletion(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.AsyncStatus status)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_intintGuid__ulong__int<global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics>(
									__this, 
									((int)traceLevel), 
									((int)source), 
									platformId, 
									operationId, 
									((int)status), 
									global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_TraceOperationCompletion
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TraceOperationRelation(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.Diagnostics.CausalityRelation relation)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_intintGuid__ulong__int<global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics>(
									__this, 
									((int)traceLevel), 
									((int)source), 
									platformId, 
									operationId, 
									((int)relation), 
									global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_TraceOperationRelation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TraceSynchronousWorkStart(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.Diagnostics.CausalitySynchronousWork work)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_intintGuid__ulong__int<global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics>(
									__this, 
									((int)traceLevel), 
									((int)source), 
									platformId, 
									operationId, 
									((int)work), 
									global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_TraceSynchronousWorkStart
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceSynchronousWorkCompletion, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void TraceSynchronousWorkCompletion(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::Windows.Foundation.Diagnostics.CausalitySynchronousWork work)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics).TypeHandle, 
									global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_TraceSynchronousWorkCompletion, 
									((int)traceLevel), 
									((int)source), 
									((int)work)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			// Signature, Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.add_TracingStatusChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] System_EventHandler_1_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs___Windows_Foundation__EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TracingStatusChanged(
						global::System.__ComObject __this, 
						global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs> handler)
			{
				// Setup
				global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl** unsafe_handler = default(global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_cookie__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken cookie__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget147>(global::System.EventHandler_A_Windows_Foundation_Diagnostics_TracingStatusChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics).TypeHandle, 
										global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_add_TracingStatusChanged, 
										unsafe_handler, 
										&(unsafe_cookie__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					cookie__retval = unsafe_cookie__retval;
					// Return
					return cookie__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TracingStatusChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken cookie)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics>(
									__this, 
									cookie, 
									global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.Vtbl.idx_remove_TracingStatusChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceOperationCreation(
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						string operationName, 
						ulong relatedContext)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.TraceOperationCreation(
									this, 
									traceLevel, 
									source, 
									platformId, 
									operationId, 
									operationName, 
									relatedContext
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceOperationCompletion(
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.AsyncStatus status)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.TraceOperationCompletion(
									this, 
									traceLevel, 
									source, 
									platformId, 
									operationId, 
									status
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceOperationRelation(
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.Diagnostics.CausalityRelation relation)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.TraceOperationRelation(
									this, 
									traceLevel, 
									source, 
									platformId, 
									operationId, 
									relation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceSynchronousWorkStart(
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::System.Guid platformId, 
						ulong operationId, 
						global::Windows.Foundation.Diagnostics.CausalitySynchronousWork work)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.TraceSynchronousWorkStart(
									this, 
									traceLevel, 
									source, 
									platformId, 
									operationId, 
									work
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TraceSynchronousWorkCompletion(
						global::Windows.Foundation.Diagnostics.CausalityTraceLevel traceLevel, 
						global::Windows.Foundation.Diagnostics.CausalitySource source, 
						global::Windows.Foundation.Diagnostics.CausalitySynchronousWork work)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.TraceSynchronousWorkCompletion(
									this, 
									traceLevel, 
									source, 
									work
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TracingStatusChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.add_TracingStatusChanged(global::System.EventHandler<global::Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs> handler)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.add_TracingStatusChanged(
									this, 
									handler
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.TracingStatusChanged")]
			void global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics.remove_TracingStatusChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken cookie)
			{
				global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics__Impl.StubClass.remove_TracingStatusChanged(
									this, 
									cookie
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Diagnostics.IAsyncCausalityTracerStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_TraceOperationCreation = 6;
			internal const int idx_TraceOperationCompletion = 7;
			internal const int idx_TraceOperationRelation = 8;
			internal const int idx_TraceSynchronousWorkStart = 9;
			internal const int idx_TraceSynchronousWorkCompletion = 10;
			internal const int idx_add_TracingStatusChanged = 11;
			internal const int idx_remove_TracingStatusChanged = 12;
		}
	}
}

namespace Windows.Foundation.Metadata
{
	// Windows.Foundation.Metadata.IApiInformationStatics
	public unsafe static class IApiInformationStatics__Impl
	{
		// StubClass for 'Windows.Foundation.Metadata.IApiInformationStatics'
		public static partial class StubClass
		{
			// Signature, Windows.Foundation.Metadata.IApiInformationStatics.IsTypePresent, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsTypePresent(
						global::System.__ComObject __this, 
						string typeName)
			{
				// Setup
				global::System.Runtime.InteropServices.HSTRING unsafe_typeName = default(global::System.Runtime.InteropServices.HSTRING);
				bool value__retval;
				sbyte unsafe_value__retval;
				int unsafe___return__;
				// Marshalling
				fixed (char* pBuffer_typeName = typeName)
				{
					global::System.Runtime.InteropServices.HSTRING_HEADER hstring_header_typeName;
					global::System.Runtime.InteropServices.McgMarshal.StringToHStringReference(pBuffer_typeName, typeName, &(hstring_header_typeName), &(unsafe_typeName));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Foundation.Metadata.IApiInformationStatics).TypeHandle, 
										global::Windows.Foundation.Metadata.IApiInformationStatics__Impl.Vtbl.idx_IsTypePresent, 
										unsafe_typeName, 
										&(unsafe_value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					value__retval = unsafe_value__retval != 0;
				}
				// Return
				return value__retval;
			}
		}

		// DispatchClass for 'Windows.Foundation.Metadata.IApiInformationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Metadata.IApiInformationStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Foundation.Metadata.IApiInformationStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.Foundation.Metadata.IApiInformationStatics.IsTypePresent(string typeName)
			{
				bool __retVal = global::Windows.Foundation.Metadata.IApiInformationStatics__Impl.StubClass.IsTypePresent(
									this, 
									typeName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Foundation.Metadata.IApiInformationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Foundation.Metadata.IApiInformationStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_IsTypePresent = 6;
		}
	}
}

namespace Windows.Globalization
{
	// Windows.Globalization.ICalendar
	public unsafe static class ICalendar__Impl
	{
		// StubClass for 'Windows.Globalization.ICalendar'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ChangeCalendarSystem(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.Globalization.ICalendar>(
									__this, 
									value, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_ChangeCalendarSystem
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.DateTimeOffset GetDateTime(global::System.__ComObject __this)
			{
				global::System.DateTimeOffset __ret = global::McgInterop.ForwardComSharedStubs.Func_DateTimeOffset__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_GetDateTime
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int get_LastEra(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_get_LastEra
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Era(
						global::System.__ComObject __this, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									value, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_put_Era
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string EraAsString(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_EraAsFullString
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.Globalization.ICalendar.EraAsString, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string EraAsString(
						global::System.__ComObject __this, 
						int idealLength)
			{
				// Setup
				global::System.Runtime.InteropServices.HSTRING unsafe_result__retval = default(global::System.Runtime.InteropServices.HSTRING);
				string result__retval = default(string);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_result__retval = default(global::System.Runtime.InteropServices.HSTRING);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Globalization.ICalendar).TypeHandle, 
										global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_EraAsString, 
										idealLength, 
										&(unsafe_result__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					result__retval = global::System.Runtime.InteropServices.McgMarshal.HStringToString(unsafe_result__retval);
					// Return
					return result__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.FreeHString(unsafe_result__retval.handle);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int get_FirstYearInThisEra(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_get_FirstYearInThisEra
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Year(
						global::System.__ComObject __this, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									value, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_put_Year
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int get_FirstMonthInThisYear(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_get_FirstMonthInThisYear
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Month(
						global::System.__ComObject __this, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									value, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_put_Month
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int get_FirstDayInThisMonth(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_get_FirstDayInThisMonth
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int get_Day(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_get_Day
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Day(
						global::System.__ComObject __this, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int__<global::Windows.Globalization.ICalendar>(
									__this, 
									value, 
									global::Windows.Globalization.ICalendar__Impl.Vtbl.idx_put_Day
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Globalization.ICalendar'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ICalendar))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.ICalendar
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Globalization.ICalendar.ChangeCalendarSystem(string value)
			{
				global::Windows.Globalization.ICalendar__Impl.StubClass.ChangeCalendarSystem(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.DateTimeOffset global::Windows.Globalization.ICalendar.GetDateTime()
			{
				global::System.DateTimeOffset __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.GetDateTime(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendar.LastEra")]
			int global::Windows.Globalization.ICalendar.get_LastEra()
			{
				int __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.get_LastEra(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Globalization.ICalendar.Era")]
			void global::Windows.Globalization.ICalendar.put_Era(int value)
			{
				global::Windows.Globalization.ICalendar__Impl.StubClass.put_Era(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.Globalization.ICalendar.EraAsString()
			{
				string __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.EraAsString(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.Globalization.ICalendar.EraAsString(int idealLength)
			{
				string __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.EraAsString(
									this, 
									idealLength
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendar.FirstYearInThisEra")]
			int global::Windows.Globalization.ICalendar.get_FirstYearInThisEra()
			{
				int __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.get_FirstYearInThisEra(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Globalization.ICalendar.Year")]
			void global::Windows.Globalization.ICalendar.put_Year(int value)
			{
				global::Windows.Globalization.ICalendar__Impl.StubClass.put_Year(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendar.FirstMonthInThisYear")]
			int global::Windows.Globalization.ICalendar.get_FirstMonthInThisYear()
			{
				int __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.get_FirstMonthInThisYear(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Globalization.ICalendar.Month")]
			void global::Windows.Globalization.ICalendar.put_Month(int value)
			{
				global::Windows.Globalization.ICalendar__Impl.StubClass.put_Month(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendar.FirstDayInThisMonth")]
			int global::Windows.Globalization.ICalendar.get_FirstDayInThisMonth()
			{
				int __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.get_FirstDayInThisMonth(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendar.Day")]
			int global::Windows.Globalization.ICalendar.get_Day()
			{
				int __retVal = global::Windows.Globalization.ICalendar__Impl.StubClass.get_Day(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Globalization.ICalendar.Day")]
			void global::Windows.Globalization.ICalendar.put_Day(int value)
			{
				global::Windows.Globalization.ICalendar__Impl.StubClass.put_Day(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Globalization.ICalendar'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ICalendar))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_ChangeCalendarSystem = 13;
			internal const int idx_GetDateTime = 16;
			internal const int idx_get_LastEra = 20;
			internal const int idx_put_Era = 23;
			internal const int idx_EraAsFullString = 25;
			internal const int idx_EraAsString = 26;
			internal const int idx_get_FirstYearInThisEra = 27;
			internal const int idx_put_Year = 31;
			internal const int idx_get_FirstMonthInThisYear = 36;
			internal const int idx_put_Month = 40;
			internal const int idx_get_FirstDayInThisMonth = 49;
			internal const int idx_get_Day = 52;
			internal const int idx_put_Day = 53;
		}
	}

	// Windows.Globalization.ITimeZoneOnCalendar
	public unsafe static class ITimeZoneOnCalendar__Impl
	{
		// v-table for 'Windows.Globalization.ITimeZoneOnCalendar'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ITimeZoneOnCalendar))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Globalization.ILanguageFactory
	public unsafe static class ILanguageFactory__Impl
	{
		// StubClass for 'Windows.Globalization.ILanguageFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateLanguage(
						global::System.__ComObject __this, 
						string languageTag)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_string__IntPtr__<global::Windows.Globalization.ILanguageFactory>(
									__this, 
									languageTag, 
									global::Windows.Globalization.ILanguageFactory__Impl.Vtbl.idx_CreateLanguage
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Globalization.ILanguageFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ILanguageFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.ILanguageFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.Globalization.ILanguageFactory.CreateLanguage(string languageTag)
			{
				global::System.IntPtr __retVal = global::Windows.Globalization.ILanguageFactory__Impl.StubClass.CreateLanguage(
									this, 
									languageTag
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Globalization.ILanguageFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ILanguageFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateLanguage = 6;
		}
	}

	// Windows.Globalization.ILanguage
	public unsafe static class ILanguage__Impl
	{
		// StubClass for 'Windows.Globalization.ILanguage'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_DisplayName(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.ILanguage>(
									__this, 
									global::Windows.Globalization.ILanguage__Impl.Vtbl.idx_get_DisplayName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Globalization.ILanguage'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ILanguage))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.ILanguage
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ILanguage.DisplayName")]
			string global::Windows.Globalization.ILanguage.get_DisplayName()
			{
				string __retVal = global::Windows.Globalization.ILanguage__Impl.StubClass.get_DisplayName(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Globalization.ILanguage'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ILanguage))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_DisplayName = 7;
		}
	}

	// Windows.Globalization.ILanguageExtensionSubtags
	public unsafe static class ILanguageExtensionSubtags__Impl
	{
		// v-table for 'Windows.Globalization.ILanguageExtensionSubtags'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ILanguageExtensionSubtags))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Globalization.IGeographicRegionFactory
	public unsafe static class IGeographicRegionFactory__Impl
	{
		// StubClass for 'Windows.Globalization.IGeographicRegionFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateGeographicRegion(
						global::System.__ComObject __this, 
						string geographicRegionCode)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_string__IntPtr__<global::Windows.Globalization.IGeographicRegionFactory>(
									__this, 
									geographicRegionCode, 
									global::Windows.Globalization.IGeographicRegionFactory__Impl.Vtbl.idx_CreateGeographicRegion
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Globalization.IGeographicRegionFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.IGeographicRegionFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.IGeographicRegionFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.Globalization.IGeographicRegionFactory.CreateGeographicRegion(string geographicRegionCode)
			{
				global::System.IntPtr __retVal = global::Windows.Globalization.IGeographicRegionFactory__Impl.StubClass.CreateGeographicRegion(
									this, 
									geographicRegionCode
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Globalization.IGeographicRegionFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.IGeographicRegionFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateGeographicRegion = 6;
		}
	}

	// Windows.Globalization.IGeographicRegion
	public unsafe static class IGeographicRegion__Impl
	{
		// StubClass for 'Windows.Globalization.IGeographicRegion'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_DisplayName(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.IGeographicRegion>(
									__this, 
									global::Windows.Globalization.IGeographicRegion__Impl.Vtbl.idx_get_DisplayName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Globalization.IGeographicRegion'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.IGeographicRegion))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.IGeographicRegion
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.IGeographicRegion.DisplayName")]
			string global::Windows.Globalization.IGeographicRegion.get_DisplayName()
			{
				string __retVal = global::Windows.Globalization.IGeographicRegion__Impl.StubClass.get_DisplayName(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Globalization.IGeographicRegion'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.IGeographicRegion))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_DisplayName = 10;
		}
	}

	// Windows.Globalization.ICalendarIdentifiersStatics
	public unsafe static class ICalendarIdentifiersStatics__Impl
	{
		// StubClass for 'Windows.Globalization.ICalendarIdentifiersStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Gregorian(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.ICalendarIdentifiersStatics>(
									__this, 
									global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.Vtbl.idx_get_Gregorian
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Hijri(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.ICalendarIdentifiersStatics>(
									__this, 
									global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.Vtbl.idx_get_Hijri
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Japanese(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Globalization.ICalendarIdentifiersStatics>(
									__this, 
									global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.Vtbl.idx_get_Japanese
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Globalization.ICalendarIdentifiersStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ICalendarIdentifiersStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Globalization.ICalendarIdentifiersStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendarIdentifiersStatics.Gregorian")]
			string global::Windows.Globalization.ICalendarIdentifiersStatics.get_Gregorian()
			{
				string __retVal = global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.StubClass.get_Gregorian(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendarIdentifiersStatics.Hijri")]
			string global::Windows.Globalization.ICalendarIdentifiersStatics.get_Hijri()
			{
				string __retVal = global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.StubClass.get_Hijri(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Globalization.ICalendarIdentifiersStatics.Japanese")]
			string global::Windows.Globalization.ICalendarIdentifiersStatics.get_Japanese()
			{
				string __retVal = global::Windows.Globalization.ICalendarIdentifiersStatics__Impl.StubClass.get_Japanese(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Globalization.ICalendarIdentifiersStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Globalization.ICalendarIdentifiersStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Gregorian = 6;
			internal const int idx_get_Hijri = 8;
			internal const int idx_get_Japanese = 9;
		}
	}
}

namespace Windows.Security.Cryptography
{
	// Windows.Security.Cryptography.ICryptographicBufferStatics
	public unsafe static class ICryptographicBufferStatics__Impl
	{
		// StubClass for 'Windows.Security.Cryptography.ICryptographicBufferStatics'
		public static partial class StubClass
		{
			// Signature, Windows.Security.Cryptography.ICryptographicBufferStatics.CreateFromByteArray, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableArrayMarshaller] rg_byte__unsigned char *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Storage_Streams_IBuffer__Windows_Storage_Streams__IBuffer *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.Streams.IBuffer CreateFromByteArray(
						global::System.__ComObject __this, 
						byte[] value)
			{
				// Setup
				uint unsafe_value_mcgLength = 0;
				byte* unsafe_value;
				global::Windows.Storage.Streams.IBuffer__Impl.Vtbl** unsafe_buffer__retval = default(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl**);
				global::Windows.Storage.Streams.IBuffer buffer__retval = default(global::Windows.Storage.Streams.IBuffer);
				int unsafe___return__;
				try
				{
					// Marshalling
					if (value != null)
						unsafe_value_mcgLength = (uint)value.Length;
					fixed (byte* pinned_value = global::McgInterop.McgCoreHelpers.GetArrayForCompat(value))
					{
						unsafe_value = (byte*)pinned_value;
						unsafe_buffer__retval = null;
						// Call to native method
						unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
											__this, 
											typeof(global::Windows.Security.Cryptography.ICryptographicBufferStatics).TypeHandle, 
											global::Windows.Security.Cryptography.ICryptographicBufferStatics__Impl.Vtbl.idx_CreateFromByteArray, 
											unsafe_value_mcgLength, 
											unsafe_value, 
											&(unsafe_buffer__retval)
										);
						global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
						buffer__retval = (global::Windows.Storage.Streams.IBuffer)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
											((global::System.IntPtr)unsafe_buffer__retval), 
											typeof(global::Windows.Storage.Streams.IBuffer).TypeHandle
										);
					}
					// Return
					return buffer__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_buffer__retval)));
				}
			}

			// Signature, Windows.Security.Cryptography.ICryptographicBufferStatics.CopyToByteArray, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Storage_Streams_IBuffer__Windows_Storage_Streams__IBuffer *, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableArrayMarshaller] rg_byte__unsigned char *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void CopyToByteArray(
						global::System.__ComObject __this, 
						global::Windows.Storage.Streams.IBuffer buffer, 
						out byte[] value)
			{
				// Setup
				global::Windows.Storage.Streams.IBuffer__Impl.Vtbl** unsafe_buffer = default(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl**);
				byte* unsafe_value = default(byte*);
				uint unsafe_value_mcgLength = 0;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_buffer = (global::Windows.Storage.Streams.IBuffer__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
										buffer, 
										typeof(global::Windows.Storage.Streams.IBuffer).TypeHandle
									);
					unsafe_value = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Security.Cryptography.ICryptographicBufferStatics).TypeHandle, 
										global::Windows.Security.Cryptography.ICryptographicBufferStatics__Impl.Vtbl.idx_CopyToByteArray, 
										unsafe_buffer, 
										&(unsafe_value_mcgLength), 
										&(unsafe_value)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_value == null)
						value = null;
					else
					{
						value = new byte[unsafe_value_mcgLength];
						if (value != null)
							for (uint mcgIdx = 0; (mcgIdx < unsafe_value_mcgLength); mcgIdx++)
							{
								// [fwd] [out] [managedbyref] [nativebyref] [optional] [Mcg.CodeGen.BlittableValueMarshaller] byte__unsigned char value
								value[mcgIdx] = unsafe_value[mcgIdx];
							}
					}
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_buffer)));
					global::System.GC.KeepAlive(buffer);
					global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree(unsafe_value);
				}
			}
		}

		// DispatchClass for 'Windows.Security.Cryptography.ICryptographicBufferStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.ICryptographicBufferStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Security.Cryptography.ICryptographicBufferStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.Streams.IBuffer global::Windows.Security.Cryptography.ICryptographicBufferStatics.CreateFromByteArray(byte[] value)
			{
				global::Windows.Storage.Streams.IBuffer __retVal = global::Windows.Security.Cryptography.ICryptographicBufferStatics__Impl.StubClass.CreateFromByteArray(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Security.Cryptography.ICryptographicBufferStatics.CopyToByteArray(
						global::Windows.Storage.Streams.IBuffer buffer, 
						out byte[] value)
			{
				global::Windows.Security.Cryptography.ICryptographicBufferStatics__Impl.StubClass.CopyToByteArray(
									this, 
									buffer, 
									out value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Security.Cryptography.ICryptographicBufferStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.ICryptographicBufferStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateFromByteArray = 9;
			internal const int idx_CopyToByteArray = 10;
		}
	}
}

namespace Windows.Security.Cryptography.Core
{
	// Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics
	public unsafe static class IHashAlgorithmNamesStatics__Impl
	{
		// StubClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Sha1(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics>(
									__this, 
									global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics__Impl.Vtbl.idx_get_Sha1
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics.Sha1")]
			string global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics.get_Sha1()
			{
				string __retVal = global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics__Impl.StubClass.get_Sha1(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmNamesStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Sha1 = 7;
		}
	}

	// Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics
	public unsafe static class IHashAlgorithmProviderStatics__Impl
	{
		// StubClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Security.Cryptography.Core.HashAlgorithmProvider OpenAlgorithm(
						global::System.__ComObject __this, 
						string algorithm)
			{
				global::Windows.Security.Cryptography.Core.HashAlgorithmProvider __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics, global::Windows.Security.Cryptography.Core.HashAlgorithmProvider>(
									__this, 
									algorithm, 
									global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics__Impl.Vtbl.idx_OpenAlgorithm
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Security.Cryptography.Core.HashAlgorithmProvider global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics.OpenAlgorithm(string algorithm)
			{
				global::Windows.Security.Cryptography.Core.HashAlgorithmProvider __retVal = global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics__Impl.StubClass.OpenAlgorithm(
									this, 
									algorithm
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmProviderStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OpenAlgorithm = 6;
		}
	}

	// Windows.Security.Cryptography.Core.IHashAlgorithmProvider
	public unsafe static class IHashAlgorithmProvider__Impl
	{
		// StubClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmProvider'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Storage.Streams.IBuffer HashData(
						global::System.__ComObject __this, 
						global::Windows.Storage.Streams.IBuffer data)
			{
				global::Windows.Storage.Streams.IBuffer __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__TResult__<global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider, global::Windows.Storage.Streams.IBuffer, global::Windows.Storage.Streams.IBuffer>(
									__this, 
									data, 
									global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider__Impl.Vtbl.idx_HashData
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Security.Cryptography.Core.IHashAlgorithmProvider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Storage.Streams.IBuffer global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider.HashData(global::Windows.Storage.Streams.IBuffer data)
			{
				global::Windows.Storage.Streams.IBuffer __retVal = global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider__Impl.StubClass.HashData(
									this, 
									data
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Security.Cryptography.Core.IHashAlgorithmProvider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Security.Cryptography.Core.IHashAlgorithmProvider))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_HashData = 8;
		}
	}
}

namespace Windows.Storage
{
	// Windows.Storage.IStorageItem
	public unsafe static class IStorageItem__Impl
	{
		// StubClass for 'Windows.Storage.IStorageItem'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Path(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.Storage.IStorageItem>(
									__this, 
									global::Windows.Storage.IStorageItem__Impl.Vtbl.idx_get_Path
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Storage.IStorageItem'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItem))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.IStorageItem
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.IStorageItem.Path")]
			string global::Windows.Storage.IStorageItem.get_Path()
			{
				string __retVal = global::Windows.Storage.IStorageItem__Impl.StubClass.get_Path(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.IStorageItem'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItem))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Path = 12;
		}
	}

	// Windows.Storage.IStorageFolder
	public unsafe static class IStorageFolder__Impl
	{
		// StubClass for 'Windows.Storage.IStorageFolder'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile> GetFileAsync(
						global::System.__ComObject __this, 
						string name)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile> __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.Storage.IStorageFolder, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile>>(
									__this, 
									name, 
									global::Windows.Storage.IStorageFolder__Impl.Vtbl.idx_GetFileAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem> GetItemAsync(
						global::System.__ComObject __this, 
						string name)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem> __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.Storage.IStorageFolder, global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem>>(
									__this, 
									name, 
									global::Windows.Storage.IStorageFolder__Impl.Vtbl.idx_GetItemAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Storage.IStorageFolder'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFolder))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.IStorageFolder
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.IStorageItem.Path")]
			string global::Windows.Storage.IStorageItem.get_Path()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(string);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile> global::Windows.Storage.IStorageFolder.GetFileAsync(string name)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.StorageFile> __retVal = global::Windows.Storage.IStorageFolder__Impl.StubClass.GetFileAsync(
									this, 
									name
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem> global::Windows.Storage.IStorageFolder.GetItemAsync(string name)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.IStorageItem> __retVal = global::Windows.Storage.IStorageFolder__Impl.StubClass.GetItemAsync(
									this, 
									name
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.IStorageFolder'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFolder))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetFileAsync = 10;
			internal const int idx_GetItemAsync = 12;
		}
	}

	// Windows.Storage.IStorageFile
	public unsafe static class IStorageFile__Impl
	{
		// StubClass for 'Windows.Storage.IStorageFile'
		public static partial class StubClass
		{
			// Signature, Windows.Storage.IStorageFile.OpenAsync, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Foundation_IAsyncOperation_1_Windows_Storage_Streams_IRandomAccessStream___Windows_Foundation__IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream> OpenAsync(
						global::System.__ComObject __this, 
						global::Windows.Storage.FileAccessMode accessMode)
			{
				// Setup
				global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl** unsafe_operation__retval = default(global::Windows.Foundation.IAsyncOperation_A_Windows_Storage_Streams_IRandomAccessStream_V___Impl.Vtbl**);
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream> operation__retval = default(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_operation__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Storage.IStorageFile).TypeHandle, 
										global::Windows.Storage.IStorageFile__Impl.Vtbl.idx_OpenAsync, 
										((int)accessMode), 
										&(unsafe_operation__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					operation__retval = (global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_operation__retval), 
										typeof(global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream>).TypeHandle
									);
					// Return
					return operation__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_operation__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.Storage.IStorageFile'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFile))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.IStorageFile
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.IStorageItem.Path")]
			string global::Windows.Storage.IStorageItem.get_Path()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(string);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream> global::Windows.Storage.IStorageFile.OpenAsync(global::Windows.Storage.FileAccessMode accessMode)
			{
				global::Windows.Foundation.IAsyncOperation<global::Windows.Storage.Streams.IRandomAccessStream> __retVal = global::Windows.Storage.IStorageFile__Impl.StubClass.OpenAsync(
									this, 
									accessMode
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.IStorageFile'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFile))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OpenAsync = 8;
		}
	}

	// Windows.Storage.IStorageItemProperties
	public unsafe static class IStorageItemProperties__Impl
	{
		// v-table for 'Windows.Storage.IStorageItemProperties'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItemProperties))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageItemProperties2
	public unsafe static class IStorageItemProperties2__Impl
	{
		// v-table for 'Windows.Storage.IStorageItemProperties2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItemProperties2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageItem2
	public unsafe static class IStorageItem2__Impl
	{
		// v-table for 'Windows.Storage.IStorageItem2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItem2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageItemPropertiesWithProvider
	public unsafe static class IStorageItemPropertiesWithProvider__Impl
	{
		// v-table for 'Windows.Storage.IStorageItemPropertiesWithProvider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageItemPropertiesWithProvider))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageFilePropertiesWithAvailability
	public unsafe static class IStorageFilePropertiesWithAvailability__Impl
	{
		// v-table for 'Windows.Storage.IStorageFilePropertiesWithAvailability'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFilePropertiesWithAvailability))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageFile2
	public unsafe static class IStorageFile2__Impl
	{
		// v-table for 'Windows.Storage.IStorageFile2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFile2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.IStorageFolder2
	public unsafe static class IStorageFolder2__Impl
	{
		// v-table for 'Windows.Storage.IStorageFolder2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.IStorageFolder2))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.Storage.Search
{
	// Windows.Storage.Search.IStorageFolderQueryOperations
	public unsafe static class IStorageFolderQueryOperations__Impl
	{
		// v-table for 'Windows.Storage.Search.IStorageFolderQueryOperations'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Search.IStorageFolderQueryOperations))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.Storage.Streams
{
	// Windows.Storage.Streams.IBuffer
	public unsafe static class IBuffer__Impl
	{
		// StubClass for 'Windows.Storage.Streams.IBuffer'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint get_Capacity(global::System.__ComObject __this)
			{
				uint __ret = global::McgInterop.ForwardComSharedStubs.Func_uint__<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.idx_get_Capacity
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static uint get_Length(global::System.__ComObject __this)
			{
				uint __ret = global::McgInterop.ForwardComSharedStubs.Func_uint__<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.idx_get_Length
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Length(
						global::System.__ComObject __this, 
						uint value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_uint__<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									value, 
									global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.idx_put_Length
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.Storage.Streams.IBuffer'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IBuffer))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.Streams.IBuffer
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IBuffer.Capacity")]
			uint global::Windows.Storage.Streams.IBuffer.get_Capacity()
			{
				uint __retVal = global::Windows.Storage.Streams.IBuffer__Impl.StubClass.get_Capacity(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IBuffer.Length")]
			uint global::Windows.Storage.Streams.IBuffer.get_Length()
			{
				uint __retVal = global::Windows.Storage.Streams.IBuffer__Impl.StubClass.get_Length(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Storage.Streams.IBuffer.Length")]
			void global::Windows.Storage.Streams.IBuffer.put_Length(uint value)
			{
				global::Windows.Storage.Streams.IBuffer__Impl.StubClass.put_Length(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.Storage.Streams.IBuffer'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IBuffer))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.Storage.Streams.IBuffer))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_Storage_Streams__IBuffer
			global::System.IntPtr pfnget_Capacity_Windows_Storage_Streams__IBuffer;
			global::System.IntPtr pfnget_Length_Windows_Storage_Streams__IBuffer;
			global::System.IntPtr pfnput_Length_Windows_Storage_Streams__IBuffer;
			internal const int idx_get_Capacity = 6;
			internal const int idx_get_Length = 7;
			internal const int idx_put_Length = 8;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.Windows_Storage_Streams_IBuffer__Impl_Vtbl_McgRvaContainer), "RVA_Windows_Storage_Streams_IBuffer__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.Storage.Streams.IBuffer__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.Storage.Streams.IBuffer__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnget_Capacity_Windows_Storage_Streams__IBuffer = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget134>(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.get_Capacity__STUB),
				pfnget_Length_Windows_Storage_Streams__IBuffer = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget134>(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.get_Length__STUB),
				pfnput_Length_Windows_Storage_Streams__IBuffer = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget135>(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl.put_Length__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_Capacity__STUB(
						global::System.IntPtr pComThis, 
						uint* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_uint__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_Length__STUB(
						global::System.IntPtr pComThis, 
						uint* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_uint__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int put_Length__STUB(
						global::System.IntPtr pComThis, 
						uint unsafe_value)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.Storage.Streams.IBuffer>(
									__this, 
									2
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_uint__(
									__this, 
									unsafe_value, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_Storage_Streams_IBuffer__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl), "get_Capacity__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl), "get_Length__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl), "put_Length__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_Storage_Streams_IBuffer__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.Storage.Streams.IRandomAccessStreamReference
	public unsafe static class IRandomAccessStreamReference__Impl
	{
		// v-table for 'Windows.Storage.Streams.IRandomAccessStreamReference'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IRandomAccessStreamReference))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.Streams.IInputStreamReference
	public unsafe static class IInputStreamReference__Impl
	{
		// v-table for 'Windows.Storage.Streams.IInputStreamReference'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IInputStreamReference))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.Storage.Streams.IRandomAccessStream
	public unsafe static class IRandomAccessStream__Impl
	{
		// StubClass for 'Windows.Storage.Streams.IRandomAccessStream'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static ulong get_Size(global::System.__ComObject __this)
			{
				ulong __ret = global::McgInterop.ForwardComSharedStubs.Func_ulong__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_get_Size
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Size(
						global::System.__ComObject __this, 
						ulong value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_ulong__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									value, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_put_Size
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static ulong get_Position(global::System.__ComObject __this)
			{
				ulong __ret = global::McgInterop.ForwardComSharedStubs.Func_ulong__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_get_Position
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Seek(
						global::System.__ComObject __this, 
						ulong position)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_ulong__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									position, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_Seek
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_CanRead(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_get_CanRead
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_CanWrite(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.Storage.Streams.IRandomAccessStream>(
									__this, 
									global::Windows.Storage.Streams.IRandomAccessStream__Impl.Vtbl.idx_get_CanWrite
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Storage.Streams.IRandomAccessStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IRandomAccessStream))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.Streams.IRandomAccessStream
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> global::Windows.Storage.Streams.IInputStream.ReadAsync(
						global::Windows.Storage.Streams.IBuffer buffer, 
						uint count, 
						global::Windows.Storage.Streams.InputStreamOptions options)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> global::Windows.Storage.Streams.IOutputStream.WriteAsync(global::Windows.Storage.Streams.IBuffer buffer)
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<bool> global::Windows.Storage.Streams.IOutputStream.FlushAsync()
			{
				global::McgInterop.McgHelpers.FailFastForReducedMethod();
				return default(global::Windows.Foundation.IAsyncOperation<bool>);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IRandomAccessStream.Size")]
			ulong global::Windows.Storage.Streams.IRandomAccessStream.get_Size()
			{
				ulong __retVal = global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.get_Size(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.Storage.Streams.IRandomAccessStream.Size")]
			void global::Windows.Storage.Streams.IRandomAccessStream.put_Size(ulong value)
			{
				global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.put_Size(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IRandomAccessStream.Position")]
			ulong global::Windows.Storage.Streams.IRandomAccessStream.get_Position()
			{
				ulong __retVal = global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.get_Position(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.Storage.Streams.IRandomAccessStream.Seek(ulong position)
			{
				global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.Seek(
									this, 
									position
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IRandomAccessStream.CanRead")]
			bool global::Windows.Storage.Streams.IRandomAccessStream.get_CanRead()
			{
				bool __retVal = global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.get_CanRead(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.Storage.Streams.IRandomAccessStream.CanWrite")]
			bool global::Windows.Storage.Streams.IRandomAccessStream.get_CanWrite()
			{
				bool __retVal = global::Windows.Storage.Streams.IRandomAccessStream__Impl.StubClass.get_CanWrite(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.Streams.IRandomAccessStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IRandomAccessStream))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Size = 6;
			internal const int idx_put_Size = 7;
			internal const int idx_get_Position = 10;
			internal const int idx_Seek = 11;
			internal const int idx_get_CanRead = 13;
			internal const int idx_get_CanWrite = 14;
		}
	}

	// Windows.Storage.Streams.IInputStream
	public unsafe static class IInputStream__Impl
	{
		// StubClass for 'Windows.Storage.Streams.IInputStream'
		public static partial class StubClass
		{
			// Signature, Windows.Storage.Streams.IInputStream.ReadAsync, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Storage_Streams_IBuffer__Windows_Storage_Streams__IBuffer *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] uint__unsigned int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller] Windows_Storage_Streams_InputStreamOptions__Windows_Storage_Streams__InputStreamOptions, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Foundation_IAsyncOperationWithProgress_2_Windows_Storage_Streams_IBuffer__uint___Windows_Foundation__IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> ReadAsync(
						global::System.__ComObject __this, 
						global::Windows.Storage.Streams.IBuffer buffer, 
						uint count, 
						global::Windows.Storage.Streams.InputStreamOptions options)
			{
				// Setup
				global::Windows.Storage.Streams.IBuffer__Impl.Vtbl** unsafe_buffer = default(global::Windows.Storage.Streams.IBuffer__Impl.Vtbl**);
				global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl** unsafe_operation__retval = default(global::Windows.Foundation.IAsyncOperationWithProgress_A_Windows_Storage_Streams_IBuffer_j_uint_V___Impl.Vtbl**);
				global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> operation__retval = default(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_buffer = (global::Windows.Storage.Streams.IBuffer__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
										buffer, 
										typeof(global::Windows.Storage.Streams.IBuffer).TypeHandle
									);
					unsafe_operation__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.Storage.Streams.IInputStream).TypeHandle, 
										global::Windows.Storage.Streams.IInputStream__Impl.Vtbl.idx_ReadAsync, 
										unsafe_buffer, 
										count, 
										options, 
										&(unsafe_operation__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					operation__retval = (global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_operation__retval), 
										typeof(global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint>).TypeHandle
									);
					// Return
					return operation__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_buffer)));
					global::System.GC.KeepAlive(buffer);
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_operation__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.Storage.Streams.IInputStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IInputStream))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.Streams.IInputStream
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> global::Windows.Storage.Streams.IInputStream.ReadAsync(
						global::Windows.Storage.Streams.IBuffer buffer, 
						uint count, 
						global::Windows.Storage.Streams.InputStreamOptions options)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress<global::Windows.Storage.Streams.IBuffer, uint> __retVal = global::Windows.Storage.Streams.IInputStream__Impl.StubClass.ReadAsync(
									this, 
									buffer, 
									count, 
									options
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.Streams.IInputStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IInputStream))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_ReadAsync = 6;
		}
	}

	// Windows.Storage.Streams.IOutputStream
	public unsafe static class IOutputStream__Impl
	{
		// StubClass for 'Windows.Storage.Streams.IOutputStream'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> WriteAsync(
						global::System.__ComObject __this, 
						global::Windows.Storage.Streams.IBuffer buffer)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__TResult__<global::Windows.Storage.Streams.IOutputStream, global::Windows.Storage.Streams.IBuffer, global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint>>(
									__this, 
									buffer, 
									global::Windows.Storage.Streams.IOutputStream__Impl.Vtbl.idx_WriteAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncOperation<bool> FlushAsync(global::System.__ComObject __this)
			{
				global::Windows.Foundation.IAsyncOperation<bool> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.Storage.Streams.IOutputStream, global::Windows.Foundation.IAsyncOperation<bool>>(
									__this, 
									global::Windows.Storage.Streams.IOutputStream__Impl.Vtbl.idx_FlushAsync
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.Storage.Streams.IOutputStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IOutputStream))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.Storage.Streams.IOutputStream
		{
			public virtual void Dispose()
			{
				global::System.IDisposable__Impl.StubClass.Close(this);
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> global::Windows.Storage.Streams.IOutputStream.WriteAsync(global::Windows.Storage.Streams.IBuffer buffer)
			{
				global::Windows.Foundation.IAsyncOperationWithProgress<uint, uint> __retVal = global::Windows.Storage.Streams.IOutputStream__Impl.StubClass.WriteAsync(
									this, 
									buffer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncOperation<bool> global::Windows.Storage.Streams.IOutputStream.FlushAsync()
			{
				global::Windows.Foundation.IAsyncOperation<bool> __retVal = global::Windows.Storage.Streams.IOutputStream__Impl.StubClass.FlushAsync(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.Storage.Streams.IOutputStream'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.Storage.Streams.IOutputStream))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_WriteAsync = 6;
			internal const int idx_FlushAsync = 7;
		}
	}
}

namespace Windows.System.Threading
{
	// Windows.System.Threading.WorkItemHandler
	public unsafe static class WorkItemHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.Foundation.IAsyncAction operation)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.System.Threading.WorkItemHandler, global::Windows.Foundation.IAsyncAction>(
								__this, 
								operation, 
								global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.System.Threading.WorkItemHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.System.Threading.WorkItemHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_System_Threading__WorkItemHandler
			global::System.IntPtr pfnInvoke_Windows_System_Threading__WorkItemHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl.Windows_System_Threading_WorkItemHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_System_Threading_WorkItemHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_System_Threading__WorkItemHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget119>(global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.Foundation.IAsyncAction__Impl.Vtbl** unsafe_operation)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.System.Threading.WorkItemHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.Foundation.IAsyncAction>(
									__this, 
									unsafe_operation, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_System_Threading_WorkItemHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_System_Threading_WorkItemHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.System.Threading.TimerElapsedHandler
	public unsafe static class TimerElapsedHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.System.Threading.ThreadPoolTimer timer)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.System.Threading.TimerElapsedHandler, global::Windows.System.Threading.ThreadPoolTimer>(
								__this, 
								timer, 
								global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.System.Threading.TimerElapsedHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.System.Threading.TimerElapsedHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_System_Threading__TimerElapsedHandler
			global::System.IntPtr pfnInvoke_Windows_System_Threading__TimerElapsedHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl.Windows_System_Threading_TimerElapsedHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_System_Threading_TimerElapsedHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_System_Threading__TimerElapsedHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget120>(global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.System.Threading.IThreadPoolTimer__Impl.Vtbl** unsafe_timer)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.System.Threading.TimerElapsedHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.System.Threading.ThreadPoolTimer>(
									__this, 
									unsafe_timer, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_System_Threading_TimerElapsedHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_System_Threading_TimerElapsedHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.System.Threading.IThreadPoolTimerStatics
	public unsafe static class IThreadPoolTimerStatics__Impl
	{
		// StubClass for 'Windows.System.Threading.IThreadPoolTimerStatics'
		public static partial class StubClass
		{
			// Signature, Windows.System.Threading.IThreadPoolTimerStatics.CreateTimer, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_System_Threading_TimerElapsedHandler__Windows_System_Threading__TimerElapsedHandler *, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] System_TimeSpan__Windows_Foundation__TimeSpan, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTClassMarshaller] Windows_System_Threading_ThreadPoolTimer__Windows_System_Threading__ThreadPoolTimer *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.System.Threading.ThreadPoolTimer CreateTimer(
						global::System.__ComObject __this, 
						global::Windows.System.Threading.TimerElapsedHandler handler, 
						global::System.TimeSpan delay)
			{
				// Setup
				global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl** unsafe_handler = default(global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl**);
				global::Windows.System.Threading.IThreadPoolTimer__Impl.Vtbl** unsafe_timer__retval = default(global::Windows.System.Threading.IThreadPoolTimer__Impl.Vtbl**);
				global::Windows.System.Threading.ThreadPoolTimer timer__retval = default(global::Windows.System.Threading.ThreadPoolTimer);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.System.Threading.TimerElapsedHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.System.Threading.TimerElapsedHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget121>(global::Windows.System.Threading.TimerElapsedHandler__Impl.Invoke)
									);
					unsafe_timer__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.System.Threading.IThreadPoolTimerStatics).TypeHandle, 
										global::Windows.System.Threading.IThreadPoolTimerStatics__Impl.Vtbl.idx_CreateTimer, 
										unsafe_handler, 
										delay, 
										&(unsafe_timer__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					timer__retval = (global::Windows.System.Threading.ThreadPoolTimer)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_timer__retval), 
										typeof(global::Windows.System.Threading.ThreadPoolTimer).TypeHandle
									);
					// Return
					return timer__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_timer__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.System.Threading.IThreadPoolTimerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolTimerStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.System.Threading.IThreadPoolTimerStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.System.Threading.ThreadPoolTimer global::Windows.System.Threading.IThreadPoolTimerStatics.CreateTimer(
						global::Windows.System.Threading.TimerElapsedHandler handler, 
						global::System.TimeSpan delay)
			{
				global::Windows.System.Threading.ThreadPoolTimer __retVal = global::Windows.System.Threading.IThreadPoolTimerStatics__Impl.StubClass.CreateTimer(
									this, 
									handler, 
									delay
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.System.Threading.IThreadPoolTimerStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolTimerStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateTimer = 7;
		}
	}

	// Windows.System.Threading.IThreadPoolTimer
	public unsafe static class IThreadPoolTimer__Impl
	{
		// StubClass for 'Windows.System.Threading.IThreadPoolTimer'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Cancel(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.System.Threading.IThreadPoolTimer>(
									__this, 
									global::Windows.System.Threading.IThreadPoolTimer__Impl.Vtbl.idx_Cancel
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.System.Threading.IThreadPoolTimer'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolTimer))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.System.Threading.IThreadPoolTimer
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.System.Threading.IThreadPoolTimer.Cancel()
			{
				global::Windows.System.Threading.IThreadPoolTimer__Impl.StubClass.Cancel(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.System.Threading.IThreadPoolTimer'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolTimer))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Cancel = 8;
		}
	}

	// Windows.System.Threading.IThreadPoolStatics
	public unsafe static class IThreadPoolStatics__Impl
	{
		// StubClass for 'Windows.System.Threading.IThreadPoolStatics'
		public static partial class StubClass
		{
			// Signature, Windows.System.Threading.IThreadPoolStatics.RunAsync, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_System_Threading_WorkItemHandler__Windows_System_Threading__WorkItemHandler *, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller] Windows_System_Threading_WorkItemOptions__Windows_System_Threading__WorkItemOptions, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Foundation_IAsyncAction__Windows_Foundation__IAsyncAction *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncAction RunAsync(
						global::System.__ComObject __this, 
						global::Windows.System.Threading.WorkItemHandler handler, 
						global::Windows.System.Threading.WorkItemPriority priority, 
						global::Windows.System.Threading.WorkItemOptions options)
			{
				// Setup
				global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl** unsafe_handler = default(global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl**);
				global::Windows.Foundation.IAsyncAction__Impl.Vtbl** unsafe_operation__retval = default(global::Windows.Foundation.IAsyncAction__Impl.Vtbl**);
				global::Windows.Foundation.IAsyncAction operation__retval = default(global::Windows.Foundation.IAsyncAction);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_handler = (global::Windows.System.Threading.WorkItemHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										handler, 
										typeof(global::Windows.System.Threading.WorkItemHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget133>(global::Windows.System.Threading.WorkItemHandler__Impl.Invoke)
									);
					unsafe_operation__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.System.Threading.IThreadPoolStatics).TypeHandle, 
										global::Windows.System.Threading.IThreadPoolStatics__Impl.Vtbl.idx_RunWithPriorityAndOptionsAsync, 
										unsafe_handler, 
										((int)priority), 
										options, 
										&(unsafe_operation__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					operation__retval = (global::Windows.Foundation.IAsyncAction)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_operation__retval), 
										typeof(global::Windows.Foundation.IAsyncAction).TypeHandle
									);
					// Return
					return operation__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_handler)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_operation__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.System.Threading.IThreadPoolStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.System.Threading.IThreadPoolStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncAction global::Windows.System.Threading.IThreadPoolStatics.RunAsync(
						global::Windows.System.Threading.WorkItemHandler handler, 
						global::Windows.System.Threading.WorkItemPriority priority, 
						global::Windows.System.Threading.WorkItemOptions options)
			{
				global::Windows.Foundation.IAsyncAction __retVal = global::Windows.System.Threading.IThreadPoolStatics__Impl.StubClass.RunAsync(
									this, 
									handler, 
									priority, 
									options
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.System.Threading.IThreadPoolStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.System.Threading.IThreadPoolStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_RunWithPriorityAndOptionsAsync = 8;
		}
	}
}

namespace Windows.UI.Core
{
	// Windows.UI.Core.ICoreDispatcher
	public unsafe static class ICoreDispatcher__Impl
	{
		// StubClass for 'Windows.UI.Core.ICoreDispatcher'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_HasThreadAccess(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Core.ICoreDispatcher>(
									__this, 
									global::Windows.UI.Core.ICoreDispatcher__Impl.Vtbl.idx_get_HasThreadAccess
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Core.ICoreDispatcher.RunAsync, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Core_DispatchedHandler__Windows_UI_Core__DispatchedHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_Foundation_IAsyncAction__Windows_Foundation__IAsyncAction *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.IAsyncAction RunAsync(
						global::System.__ComObject __this, 
						global::Windows.UI.Core.CoreDispatcherPriority priority, 
						global::Windows.UI.Core.DispatchedHandler agileCallback)
			{
				// Setup
				global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl** unsafe_agileCallback = default(global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl**);
				global::Windows.Foundation.IAsyncAction__Impl.Vtbl** unsafe_asyncAction__retval = default(global::Windows.Foundation.IAsyncAction__Impl.Vtbl**);
				global::Windows.Foundation.IAsyncAction asyncAction__retval = default(global::Windows.Foundation.IAsyncAction);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_agileCallback = (global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										agileCallback, 
										typeof(global::Windows.UI.Core.DispatchedHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget122>(global::Windows.UI.Core.DispatchedHandler__Impl.Invoke)
									);
					unsafe_asyncAction__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Core.ICoreDispatcher).TypeHandle, 
										global::Windows.UI.Core.ICoreDispatcher__Impl.Vtbl.idx_RunAsync, 
										((int)priority), 
										unsafe_agileCallback, 
										&(unsafe_asyncAction__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					asyncAction__retval = (global::Windows.Foundation.IAsyncAction)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_asyncAction__retval), 
										typeof(global::Windows.Foundation.IAsyncAction).TypeHandle
									);
					// Return
					return asyncAction__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_agileCallback)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_asyncAction__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Core.ICoreDispatcher'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreDispatcher))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Core.ICoreDispatcher
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Core.ICoreDispatcher.HasThreadAccess")]
			bool global::Windows.UI.Core.ICoreDispatcher.get_HasThreadAccess()
			{
				bool __retVal = global::Windows.UI.Core.ICoreDispatcher__Impl.StubClass.get_HasThreadAccess(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.IAsyncAction global::Windows.UI.Core.ICoreDispatcher.RunAsync(
						global::Windows.UI.Core.CoreDispatcherPriority priority, 
						global::Windows.UI.Core.DispatchedHandler agileCallback)
			{
				global::Windows.Foundation.IAsyncAction __retVal = global::Windows.UI.Core.ICoreDispatcher__Impl.StubClass.RunAsync(
									this, 
									priority, 
									agileCallback
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Core.ICoreDispatcher'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreDispatcher))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_HasThreadAccess = 6;
			internal const int idx_RunAsync = 8;
		}
	}

	// Windows.UI.Core.ICoreAcceleratorKeys
	public unsafe static class ICoreAcceleratorKeys__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreAcceleratorKeys'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreAcceleratorKeys))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.DispatchedHandler
	public unsafe static class DispatchedHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(this global::System.__ComObject __this)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Core.DispatchedHandler>(
								__this, 
								global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Core.DispatchedHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Core.DispatchedHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Core__DispatchedHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Core__DispatchedHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl.Windows_UI_Core_DispatchedHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Core_DispatchedHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Core__DispatchedHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget114>(global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(global::System.IntPtr pComThis)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Core.DispatchedHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_(
									__this, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Core_DispatchedHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Core.DispatchedHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Core_DispatchedHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Core.ICoreDispatcherWithTaskPriority
	public unsafe static class ICoreDispatcherWithTaskPriority__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreDispatcherWithTaskPriority'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreDispatcherWithTaskPriority))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.ICoreDispatcher2
	public unsafe static class ICoreDispatcher2__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreDispatcher2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreDispatcher2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.ICoreWindowStatic
	public unsafe static class ICoreWindowStatic__Impl
	{
		// StubClass for 'Windows.UI.Core.ICoreWindowStatic'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Core.CoreWindow GetForCurrentThread(global::System.__ComObject __this)
			{
				global::Windows.UI.Core.CoreWindow __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Core.ICoreWindowStatic, global::Windows.UI.Core.CoreWindow>(
									__this, 
									global::Windows.UI.Core.ICoreWindowStatic__Impl.Vtbl.idx_GetForCurrentThread
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Core.ICoreWindowStatic'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindowStatic))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Core.ICoreWindowStatic
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Core.CoreWindow global::Windows.UI.Core.ICoreWindowStatic.GetForCurrentThread()
			{
				global::Windows.UI.Core.CoreWindow __retVal = global::Windows.UI.Core.ICoreWindowStatic__Impl.StubClass.GetForCurrentThread(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Core.ICoreWindowStatic'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindowStatic))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetForCurrentThread = 6;
		}
	}

	// Windows.UI.Core.ICoreWindow
	public unsafe static class ICoreWindow__Impl
	{
		// StubClass for 'Windows.UI.Core.ICoreWindow'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Core.CoreDispatcher get_Dispatcher(global::System.__ComObject __this)
			{
				global::Windows.UI.Core.CoreDispatcher __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Core.ICoreWindow, global::Windows.UI.Core.CoreDispatcher>(
									__this, 
									global::Windows.UI.Core.ICoreWindow__Impl.Vtbl.idx_get_Dispatcher
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Core.ICoreWindow'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindow))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Core.ICoreWindow
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Core.ICoreWindow.Dispatcher")]
			global::Windows.UI.Core.CoreDispatcher global::Windows.UI.Core.ICoreWindow.get_Dispatcher()
			{
				global::Windows.UI.Core.CoreDispatcher __retVal = global::Windows.UI.Core.ICoreWindow__Impl.StubClass.get_Dispatcher(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Core.ICoreWindow'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindow))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Dispatcher = 9;
		}
	}

	// Windows.UI.Core.ICoreWindow2
	public unsafe static class ICoreWindow2__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreWindow2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindow2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.ICorePointerRedirector
	public unsafe static class ICorePointerRedirector__Impl
	{
		// v-table for 'Windows.UI.Core.ICorePointerRedirector'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICorePointerRedirector))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.ICoreWindow3
	public unsafe static class ICoreWindow3__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreWindow3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindow3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.IWindowActivatedEventArgs
	public unsafe static class IWindowActivatedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Core.IWindowActivatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.IWindowActivatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.ICoreWindowEventArgs
	public unsafe static class ICoreWindowEventArgs__Impl
	{
		// v-table for 'Windows.UI.Core.ICoreWindowEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.ICoreWindowEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.IWindowSizeChangedEventArgs
	public unsafe static class IWindowSizeChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Core.IWindowSizeChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.IWindowSizeChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Core.IVisibilityChangedEventArgs
	public unsafe static class IVisibilityChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Core.IVisibilityChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Core.IVisibilityChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Text
{
	// Windows.UI.Text.FontWeight
	public unsafe static class FontWeight__Impl
	{
	}
}

namespace Windows.UI.Xaml
{
	// Windows.UI.Xaml.IApplicationFactory
	public unsafe static class IApplicationFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplicationFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.IApplicationFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.IApplicationFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplicationFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplicationFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.IApplicationFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.IApplicationFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplicationFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.IApplicationStatics
	public unsafe static class IApplicationStatics__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplicationStatics'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IApplicationStatics.Start, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_ApplicationInitializationCallback__Windows_UI_Xaml__ApplicationInitializationCallback *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Start(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.ApplicationInitializationCallback callback)
			{
				// Setup
				global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl** unsafe_callback = default(global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_callback = (global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										callback, 
										typeof(global::Windows.UI.Xaml.ApplicationInitializationCallback).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget4>(global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplicationStatics).TypeHandle, 
										global::Windows.UI.Xaml.IApplicationStatics__Impl.Vtbl.idx_Start, 
										unsafe_callback
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_callback)));
				}
			}

			// Signature, Windows.UI.Xaml.IApplicationStatics.LoadComponent, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [in] [Mcg.CodeGen.WinRTUriMarshaller] System_Uri__Windows_Foundation__Uri, [fwd] [in] [Mcg.CodeGen.EnumMarshaller]  -> int, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void LoadComponent(
						global::System.__ComObject __this, 
						object component, 
						global::System.Uri resourceLocator, 
						global::Windows.UI.Xaml.Controls.Primitives.ComponentResourceLocation componentResourceLocation)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_component = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_resourceLocator = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_component = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(component);
					if (resourceLocator != null)
						unsafe_resourceLocator = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::McgInterop.McgHelpers.SystemUri2WindowsFoundationUri(resourceLocator);
					else
						unsafe_resourceLocator = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplicationStatics).TypeHandle, 
										global::Windows.UI.Xaml.IApplicationStatics__Impl.Vtbl.idx_LoadComponentWithResourceLocation, 
										unsafe_component, 
										unsafe_resourceLocator, 
										((int)componentResourceLocation)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_component)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_resourceLocator)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplicationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplicationStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationStatics.Start(global::Windows.UI.Xaml.ApplicationInitializationCallback callback)
			{
				global::Windows.UI.Xaml.IApplicationStatics__Impl.StubClass.Start(
									this, 
									callback
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationStatics.LoadComponent(
						object component, 
						global::System.Uri resourceLocator, 
						global::Windows.UI.Xaml.Controls.Primitives.ComponentResourceLocation componentResourceLocation)
			{
				global::Windows.UI.Xaml.IApplicationStatics__Impl.StubClass.LoadComponent(
									this, 
									component, 
									resourceLocator, 
									componentResourceLocation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplicationStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Start = 7;
			internal const int idx_LoadComponentWithResourceLocation = 9;
		}
	}

	// Windows.UI.Xaml.ApplicationInitializationCallback
	public unsafe static class ApplicationInitializationCallback__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					global::Windows.UI.Xaml.ApplicationInitializationCallbackParams p)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.ApplicationInitializationCallback, global::Windows.UI.Xaml.ApplicationInitializationCallbackParams>(
								__this, 
								p, 
								global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.ApplicationInitializationCallback'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.ApplicationInitializationCallback))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__ApplicationInitializationCallback
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__ApplicationInitializationCallback;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl.Windows_UI_Xaml_ApplicationInitializationCallback__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_ApplicationInitializationCallback__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__ApplicationInitializationCallback = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget5>(global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IApplicationInitializationCallbackParams__Impl.Vtbl** unsafe_p)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.ApplicationInitializationCallback>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.ApplicationInitializationCallbackParams>(
									__this, 
									unsafe_p, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_ApplicationInitializationCallback__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.ApplicationInitializationCallback__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_ApplicationInitializationCallback__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IApplicationInitializationCallbackParams
	public unsafe static class IApplicationInitializationCallbackParams__Impl
	{
		// v-table for 'Windows.UI.Xaml.IApplicationInitializationCallbackParams'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationInitializationCallbackParams))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IApplication
	public unsafe static class IApplication__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplication'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IApplication.get_RequestedTheme, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_ApplicationTheme__Windows_UI_Xaml__ApplicationTheme, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.ApplicationTheme get_RequestedTheme(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.ApplicationTheme unsafe_value__retval;
				global::Windows.UI.Xaml.ApplicationTheme value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IApplication).TypeHandle, 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_get_RequestedTheme, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_RequestedTheme(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.ApplicationTheme value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.IApplication>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_put_RequestedTheme
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IApplication.add_UnhandledException, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_UnhandledExceptionEventHandler__Windows_UI_Xaml__UnhandledExceptionEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_UnhandledException(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.UnhandledExceptionEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.UnhandledExceptionEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget6>(global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplication).TypeHandle, 
										global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_add_UnhandledException, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_UnhandledException(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_remove_UnhandledException
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IApplication.add_Suspending, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_SuspendingEventHandler__Windows_UI_Xaml__SuspendingEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Suspending(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.SuspendingEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.SuspendingEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget7>(global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplication).TypeHandle, 
										global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_add_Suspending, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Suspending(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_remove_Suspending
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Resuming(
						global::System.__ComObject __this, 
						global::System.EventHandler<object> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_EventHandler_1_object__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_add_Resuming
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Resuming(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IApplication__Impl.Vtbl.idx_remove_Resuming
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplication'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplication))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplication
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IApplication.RequestedTheme")]
			global::Windows.UI.Xaml.ApplicationTheme global::Windows.UI.Xaml.IApplication.get_RequestedTheme()
			{
				global::Windows.UI.Xaml.ApplicationTheme __retVal = global::Windows.UI.Xaml.IApplication__Impl.StubClass.get_RequestedTheme(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IApplication.RequestedTheme")]
			void global::Windows.UI.Xaml.IApplication.put_RequestedTheme(global::Windows.UI.Xaml.ApplicationTheme value)
			{
				global::Windows.UI.Xaml.IApplication__Impl.StubClass.put_RequestedTheme(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IApplication.UnhandledException")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IApplication.add_UnhandledException(global::Windows.UI.Xaml.UnhandledExceptionEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IApplication__Impl.StubClass.add_UnhandledException(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IApplication.UnhandledException")]
			void global::Windows.UI.Xaml.IApplication.remove_UnhandledException(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IApplication__Impl.StubClass.remove_UnhandledException(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IApplication.Suspending")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IApplication.add_Suspending(global::Windows.UI.Xaml.SuspendingEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IApplication__Impl.StubClass.add_Suspending(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IApplication.Suspending")]
			void global::Windows.UI.Xaml.IApplication.remove_Suspending(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IApplication__Impl.StubClass.remove_Suspending(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IApplication.Resuming")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IApplication.add_Resuming(global::System.EventHandler<object> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IApplication__Impl.StubClass.add_Resuming(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IApplication.Resuming")]
			void global::Windows.UI.Xaml.IApplication.remove_Resuming(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IApplication__Impl.StubClass.remove_Resuming(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplication'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplication))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_RequestedTheme = 9;
			internal const int idx_put_RequestedTheme = 10;
			internal const int idx_add_UnhandledException = 11;
			internal const int idx_remove_UnhandledException = 12;
			internal const int idx_add_Suspending = 13;
			internal const int idx_remove_Suspending = 14;
			internal const int idx_add_Resuming = 15;
			internal const int idx_remove_Resuming = 16;
		}
	}

	// Windows.UI.Xaml.UnhandledExceptionEventHandler
	public unsafe static class UnhandledExceptionEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.UnhandledExceptionEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.UnhandledExceptionEventHandler, global::Windows.UI.Xaml.UnhandledExceptionEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.UnhandledExceptionEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.UnhandledExceptionEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__UnhandledExceptionEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__UnhandledExceptionEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl.Windows_UI_Xaml_UnhandledExceptionEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_UnhandledExceptionEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__UnhandledExceptionEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget9>(global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.IUnhandledExceptionEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.UnhandledExceptionEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.UnhandledExceptionEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_UnhandledExceptionEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.UnhandledExceptionEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_UnhandledExceptionEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IUnhandledExceptionEventArgs
	public unsafe static class IUnhandledExceptionEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IUnhandledExceptionEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUnhandledExceptionEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.SuspendingEventHandler
	public unsafe static class SuspendingEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.ApplicationModel.SuspendingEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.SuspendingEventHandler, global::Windows.ApplicationModel.SuspendingEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.SuspendingEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.SuspendingEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__SuspendingEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__SuspendingEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl.Windows_UI_Xaml_SuspendingEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_SuspendingEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__SuspendingEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget10>(global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.ApplicationModel.ISuspendingEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.SuspendingEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.ApplicationModel.SuspendingEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_SuspendingEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.SuspendingEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_SuspendingEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IApplicationOverrides
	public unsafe static class IApplicationOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplicationOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.IActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnLaunched(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.LaunchActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.LaunchActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnLaunched
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnFileActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.FileActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.FileActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnFileActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnSearchActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.SearchActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.SearchActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnSearchActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnShareTargetActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnShareTargetActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnFileOpenPickerActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnFileOpenPickerActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnFileSavePickerActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnFileSavePickerActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnCachedFileUpdaterActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnCachedFileUpdaterActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnWindowCreated(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.WindowCreatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides, global::Windows.UI.Xaml.WindowCreatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.idx_OnWindowCreated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplicationOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplicationOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnActivated(global::Windows.ApplicationModel.Activation.IActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnLaunched(global::Windows.ApplicationModel.Activation.LaunchActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnLaunched(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnFileActivated(global::Windows.ApplicationModel.Activation.FileActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnFileActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnSearchActivated(global::Windows.ApplicationModel.Activation.SearchActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnSearchActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnShareTargetActivated(global::Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnShareTargetActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnFileOpenPickerActivated(global::Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnFileOpenPickerActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnFileSavePickerActivated(global::Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnFileSavePickerActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnCachedFileUpdaterActivated(global::Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnCachedFileUpdaterActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides.OnWindowCreated(global::Windows.UI.Xaml.WindowCreatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides__Impl.StubClass.OnWindowCreated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplicationOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationOverrides))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.IApplicationOverrides))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml__IApplicationOverrides
			global::System.IntPtr pfnOnActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnLaunched_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnFileActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnSearchActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnShareTargetActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnFileOpenPickerActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnFileSavePickerActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnCachedFileUpdaterActivated_Windows_UI_Xaml__IApplicationOverrides;
			global::System.IntPtr pfnOnWindowCreated_Windows_UI_Xaml__IApplicationOverrides;
			internal const int idx_OnActivated = 6;
			internal const int idx_OnLaunched = 7;
			internal const int idx_OnFileActivated = 8;
			internal const int idx_OnSearchActivated = 9;
			internal const int idx_OnShareTargetActivated = 10;
			internal const int idx_OnFileOpenPickerActivated = 11;
			internal const int idx_OnFileSavePickerActivated = 12;
			internal const int idx_OnCachedFileUpdaterActivated = 13;
			internal const int idx_OnWindowCreated = 14;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.Windows_UI_Xaml_IApplicationOverrides__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_IApplicationOverrides__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnOnActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget11>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnActivated__STUB),
				pfnOnLaunched_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget12>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnLaunched__STUB),
				pfnOnFileActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget13>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnFileActivated__STUB),
				pfnOnSearchActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget14>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnSearchActivated__STUB),
				pfnOnShareTargetActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget15>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnShareTargetActivated__STUB),
				pfnOnFileOpenPickerActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget16>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnFileOpenPickerActivated__STUB),
				pfnOnFileSavePickerActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget17>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnFileSavePickerActivated__STUB),
				pfnOnCachedFileUpdaterActivated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget18>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnCachedFileUpdaterActivated__STUB),
				pfnOnWindowCreated_Windows_UI_Xaml__IApplicationOverrides = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget19>(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl.OnWindowCreated__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.IActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.IActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnLaunched__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.LaunchActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnFileActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.IFileActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									2
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.FileActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnSearchActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.ISearchActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									3
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.SearchActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnShareTargetActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									4
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnFileOpenPickerActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									5
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnFileSavePickerActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									6
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnCachedFileUpdaterActivated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									7
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int OnWindowCreated__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.IWindowCreatedEventArgs__Impl.Vtbl** unsafe_args)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.IApplicationOverrides>(
									__this, 
									8
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.WindowCreatedEventArgs>(
									__this, 
									unsafe_args, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_IApplicationOverrides__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnLaunched__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnFileActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(36, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnSearchActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(40, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnShareTargetActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(44, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnFileOpenPickerActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(48, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnFileSavePickerActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(52, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnCachedFileUpdaterActivated__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(56, typeof(global::Windows.UI.Xaml.IApplicationOverrides__Impl.Vtbl), "OnWindowCreated__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_IApplicationOverrides__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IWindowCreatedEventArgs
	public unsafe static class IWindowCreatedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IWindowCreatedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindowCreatedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IApplication2
	public unsafe static class IApplication2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplication2'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IApplication2.add_LeavingBackground, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_LeavingBackgroundEventHandler__Windows_UI_Xaml__LeavingBackgroundEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_LeavingBackground(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.LeavingBackgroundEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.LeavingBackgroundEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget20>(global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplication2).TypeHandle, 
										global::Windows.UI.Xaml.IApplication2__Impl.Vtbl.idx_add_LeavingBackground, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_LeavingBackground(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication2>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IApplication2__Impl.Vtbl.idx_remove_LeavingBackground
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IApplication2.add_EnteredBackground, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_EnteredBackgroundEventHandler__Windows_UI_Xaml__EnteredBackgroundEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_EnteredBackground(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.EnteredBackgroundEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.EnteredBackgroundEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget21>(global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IApplication2).TypeHandle, 
										global::Windows.UI.Xaml.IApplication2__Impl.Vtbl.idx_add_EnteredBackground, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_EnteredBackground(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IApplication2>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IApplication2__Impl.Vtbl.idx_remove_EnteredBackground
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplication2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplication2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplication2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IApplication2.LeavingBackground")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IApplication2.add_LeavingBackground(global::Windows.UI.Xaml.LeavingBackgroundEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IApplication2__Impl.StubClass.add_LeavingBackground(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IApplication2.LeavingBackground")]
			void global::Windows.UI.Xaml.IApplication2.remove_LeavingBackground(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IApplication2__Impl.StubClass.remove_LeavingBackground(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IApplication2.EnteredBackground")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IApplication2.add_EnteredBackground(global::Windows.UI.Xaml.EnteredBackgroundEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IApplication2__Impl.StubClass.add_EnteredBackground(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IApplication2.EnteredBackground")]
			void global::Windows.UI.Xaml.IApplication2.remove_EnteredBackground(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IApplication2__Impl.StubClass.remove_EnteredBackground(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplication2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplication2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_LeavingBackground = 10;
			internal const int idx_remove_LeavingBackground = 11;
			internal const int idx_add_EnteredBackground = 12;
			internal const int idx_remove_EnteredBackground = 13;
		}
	}

	// Windows.UI.Xaml.LeavingBackgroundEventHandler
	public unsafe static class LeavingBackgroundEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.ApplicationModel.LeavingBackgroundEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.LeavingBackgroundEventHandler, global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.LeavingBackgroundEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.LeavingBackgroundEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__LeavingBackgroundEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__LeavingBackgroundEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl.Windows_UI_Xaml_LeavingBackgroundEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_LeavingBackgroundEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__LeavingBackgroundEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget22>(global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.ApplicationModel.ILeavingBackgroundEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.LeavingBackgroundEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.ApplicationModel.LeavingBackgroundEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_LeavingBackgroundEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.LeavingBackgroundEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_LeavingBackgroundEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.EnteredBackgroundEventHandler
	public unsafe static class EnteredBackgroundEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.ApplicationModel.EnteredBackgroundEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.EnteredBackgroundEventHandler, global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.EnteredBackgroundEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.EnteredBackgroundEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__EnteredBackgroundEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__EnteredBackgroundEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl.Windows_UI_Xaml_EnteredBackgroundEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_EnteredBackgroundEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__EnteredBackgroundEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget23>(global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.ApplicationModel.IEnteredBackgroundEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.EnteredBackgroundEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.ApplicationModel.EnteredBackgroundEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_EnteredBackgroundEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.EnteredBackgroundEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_EnteredBackgroundEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IApplicationOverrides2
	public unsafe static class IApplicationOverrides2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IApplicationOverrides2'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnBackgroundActivated(
						global::System.__ComObject __this, 
						global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IApplicationOverrides2, global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs>(
									__this, 
									args, 
									global::Windows.UI.Xaml.IApplicationOverrides2__Impl.Vtbl.idx_OnBackgroundActivated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IApplicationOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationOverrides2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IApplicationOverrides2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IApplicationOverrides2.OnBackgroundActivated(global::Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs args)
			{
				global::Windows.UI.Xaml.IApplicationOverrides2__Impl.StubClass.OnBackgroundActivated(
									this, 
									args
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IApplicationOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IApplicationOverrides2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnBackgroundActivated = 6;
		}
	}

	// Windows.UI.Xaml.IDependencyObject
	public unsafe static class IDependencyObject__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDependencyObject'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDependencyObject))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDependencyObject2
	public unsafe static class IDependencyObject2__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDependencyObject2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDependencyObject2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IUIElement
	public unsafe static class IUIElement__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IUIElement'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Transform get_RenderTransform(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Transform __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.IUIElement, global::Windows.UI.Xaml.Media.Transform>(
									__this, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_get_RenderTransform
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_RenderTransform(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Transform value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IUIElement, global::Windows.UI.Xaml.Media.Transform>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_put_RenderTransform
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Point get_RenderTransformOrigin(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Point __ret = global::McgInterop.ForwardComSharedStubs.Func__Point__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_get_RenderTransformOrigin
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.IUIElement.put_RenderTransformOrigin, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_RenderTransformOrigin(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point value)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_put_RenderTransformOrigin, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_UseLayoutRounding(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_get_UseLayoutRounding
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.IUIElement.put_UseLayoutRounding, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_UseLayoutRounding(
						global::System.__ComObject __this, 
						bool value)
			{
				// Setup
				sbyte unsafe_value;
				int unsafe___return__;
				// Marshalling
				unsafe_value = (value ? ((sbyte)1) : ((sbyte)0));
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_put_UseLayoutRounding, 
									unsafe_value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_KeyUp(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.KeyEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_KeyEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_KeyUp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_KeyUp(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_KeyUp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_KeyDown(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.KeyEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_KeyEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_KeyDown
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_KeyDown(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_KeyDown
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_GotFocus(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_GotFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_GotFocus(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_GotFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_LostFocus(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_LostFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_LostFocus(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_LostFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DragEnter(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_DragEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_DragEnter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DragEnter(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_DragEnter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DragLeave(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_DragEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_DragLeave
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DragLeave(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_DragLeave
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DragOver(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_DragEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_DragOver
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DragOver(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_DragOver
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Drop(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_DragEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_Drop
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Drop(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_Drop
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerPressed(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerPressed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerPressed(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerPressed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerMoved(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerMoved
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerMoved(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerMoved
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerReleased(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerReleased
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerReleased(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerReleased
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerEntered(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerEntered
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerEntered(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerEntered
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerExited(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerExited
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerExited(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerExited
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerCaptureLost(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerCaptureLost
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerCaptureLost(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerCaptureLost
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerCanceled(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerCanceled
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerCanceled(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerCanceled
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_PointerWheelChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Input_PointerEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_PointerWheelChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_PointerWheelChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_PointerWheelChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_Tapped, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_TappedEventHandler__Windows_UI_Xaml_Input__TappedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Tapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.TappedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.TappedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget28>(global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_Tapped, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Tapped(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_Tapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_DoubleTapped, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_DoubleTappedEventHandler__Windows_UI_Xaml_Input__DoubleTappedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DoubleTapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.DoubleTappedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget29>(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_DoubleTapped, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DoubleTapped(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_DoubleTapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_Holding, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_HoldingEventHandler__Windows_UI_Xaml_Input__HoldingEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Holding(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.HoldingEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.HoldingEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget30>(global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_Holding, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Holding(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_Holding
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_RightTapped, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_RightTappedEventHandler__Windows_UI_Xaml_Input__RightTappedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_RightTapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.RightTappedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.RightTappedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget31>(global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_RightTapped, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_RightTapped(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_RightTapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_ManipulationStarting, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_ManipulationStartingEventHandler__Windows_UI_Xaml_Input__ManipulationStartingEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ManipulationStarting(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget32>(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_ManipulationStarting, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ManipulationStarting(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_ManipulationStarting
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_ManipulationInertiaStarting, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_ManipulationInertiaStartingEventHandler__Windows_UI_Xaml_Input__ManipulationInertiaStartingEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ManipulationInertiaStarting(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget33>(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_ManipulationInertiaStarting, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ManipulationInertiaStarting(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_ManipulationInertiaStarting
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_ManipulationStarted, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_ManipulationStartedEventHandler__Windows_UI_Xaml_Input__ManipulationStartedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ManipulationStarted(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget34>(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_ManipulationStarted, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ManipulationStarted(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_ManipulationStarted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_ManipulationDelta, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_ManipulationDeltaEventHandler__Windows_UI_Xaml_Input__ManipulationDeltaEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ManipulationDelta(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget35>(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_ManipulationDelta, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ManipulationDelta(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_ManipulationDelta
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement.add_ManipulationCompleted, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Input_ManipulationCompletedEventHandler__Windows_UI_Xaml_Input__ManipulationCompletedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ManipulationCompleted(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget36>(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_add_ManipulationCompleted, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ManipulationCompleted(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement__Impl.Vtbl.idx_remove_ManipulationCompleted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IUIElement'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IUIElement
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IUIElement.RenderTransform")]
			global::Windows.UI.Xaml.Media.Transform global::Windows.UI.Xaml.IUIElement.get_RenderTransform()
			{
				global::Windows.UI.Xaml.Media.Transform __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.get_RenderTransform(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IUIElement.RenderTransform")]
			void global::Windows.UI.Xaml.IUIElement.put_RenderTransform(global::Windows.UI.Xaml.Media.Transform value)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.put_RenderTransform(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IUIElement.RenderTransformOrigin")]
			global::Windows.Foundation.Point global::Windows.UI.Xaml.IUIElement.get_RenderTransformOrigin()
			{
				global::Windows.Foundation.Point __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.get_RenderTransformOrigin(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IUIElement.RenderTransformOrigin")]
			void global::Windows.UI.Xaml.IUIElement.put_RenderTransformOrigin(global::Windows.Foundation.Point value)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.put_RenderTransformOrigin(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IUIElement.UseLayoutRounding")]
			bool global::Windows.UI.Xaml.IUIElement.get_UseLayoutRounding()
			{
				bool __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.get_UseLayoutRounding(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IUIElement.UseLayoutRounding")]
			void global::Windows.UI.Xaml.IUIElement.put_UseLayoutRounding(bool value)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.put_UseLayoutRounding(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.KeyUp")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_KeyUp(global::Windows.UI.Xaml.Input.KeyEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_KeyUp(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.KeyUp")]
			void global::Windows.UI.Xaml.IUIElement.remove_KeyUp(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_KeyUp(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.KeyDown")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_KeyDown(global::Windows.UI.Xaml.Input.KeyEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_KeyDown(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.KeyDown")]
			void global::Windows.UI.Xaml.IUIElement.remove_KeyDown(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_KeyDown(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.GotFocus")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_GotFocus(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_GotFocus(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.GotFocus")]
			void global::Windows.UI.Xaml.IUIElement.remove_GotFocus(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_GotFocus(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.LostFocus")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_LostFocus(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_LostFocus(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.LostFocus")]
			void global::Windows.UI.Xaml.IUIElement.remove_LostFocus(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_LostFocus(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.DragEnter")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_DragEnter(global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_DragEnter(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.DragEnter")]
			void global::Windows.UI.Xaml.IUIElement.remove_DragEnter(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_DragEnter(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.DragLeave")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_DragLeave(global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_DragLeave(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.DragLeave")]
			void global::Windows.UI.Xaml.IUIElement.remove_DragLeave(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_DragLeave(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.DragOver")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_DragOver(global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_DragOver(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.DragOver")]
			void global::Windows.UI.Xaml.IUIElement.remove_DragOver(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_DragOver(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.Drop")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_Drop(global::Windows.UI.Xaml.DragEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_Drop(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.Drop")]
			void global::Windows.UI.Xaml.IUIElement.remove_Drop(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_Drop(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerPressed")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerPressed(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerPressed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerPressed")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerPressed(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerPressed(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerMoved")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerMoved(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerMoved(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerMoved")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerMoved(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerMoved(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerReleased")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerReleased(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerReleased(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerReleased")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerReleased(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerReleased(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerEntered")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerEntered(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerEntered(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerEntered")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerEntered(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerEntered(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerExited")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerExited(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerExited(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerExited")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerExited(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerExited(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerCaptureLost")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerCaptureLost(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerCaptureLost(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerCaptureLost")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerCaptureLost(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerCaptureLost(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerCanceled")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerCanceled(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerCanceled(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerCanceled")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerCanceled(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerCanceled(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.PointerWheelChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_PointerWheelChanged(global::Windows.UI.Xaml.Input.PointerEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_PointerWheelChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.PointerWheelChanged")]
			void global::Windows.UI.Xaml.IUIElement.remove_PointerWheelChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_PointerWheelChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.Tapped")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_Tapped(global::Windows.UI.Xaml.Input.TappedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_Tapped(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.Tapped")]
			void global::Windows.UI.Xaml.IUIElement.remove_Tapped(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_Tapped(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.DoubleTapped")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_DoubleTapped(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_DoubleTapped(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.DoubleTapped")]
			void global::Windows.UI.Xaml.IUIElement.remove_DoubleTapped(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_DoubleTapped(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.Holding")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_Holding(global::Windows.UI.Xaml.Input.HoldingEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_Holding(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.Holding")]
			void global::Windows.UI.Xaml.IUIElement.remove_Holding(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_Holding(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.RightTapped")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_RightTapped(global::Windows.UI.Xaml.Input.RightTappedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_RightTapped(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.RightTapped")]
			void global::Windows.UI.Xaml.IUIElement.remove_RightTapped(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_RightTapped(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.ManipulationStarting")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_ManipulationStarting(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_ManipulationStarting(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.ManipulationStarting")]
			void global::Windows.UI.Xaml.IUIElement.remove_ManipulationStarting(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_ManipulationStarting(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.ManipulationInertiaStarting")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_ManipulationInertiaStarting(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_ManipulationInertiaStarting(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.ManipulationInertiaStarting")]
			void global::Windows.UI.Xaml.IUIElement.remove_ManipulationInertiaStarting(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_ManipulationInertiaStarting(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.ManipulationStarted")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_ManipulationStarted(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_ManipulationStarted(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.ManipulationStarted")]
			void global::Windows.UI.Xaml.IUIElement.remove_ManipulationStarted(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_ManipulationStarted(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.ManipulationDelta")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_ManipulationDelta(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_ManipulationDelta(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.ManipulationDelta")]
			void global::Windows.UI.Xaml.IUIElement.remove_ManipulationDelta(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_ManipulationDelta(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement.ManipulationCompleted")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement.add_ManipulationCompleted(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement__Impl.StubClass.add_ManipulationCompleted(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement.ManipulationCompleted")]
			void global::Windows.UI.Xaml.IUIElement.remove_ManipulationCompleted(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement__Impl.StubClass.remove_ManipulationCompleted(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IUIElement'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_RenderTransform = 13;
			internal const int idx_put_RenderTransform = 14;
			internal const int idx_get_RenderTransformOrigin = 17;
			internal const int idx_put_RenderTransformOrigin = 18;
			internal const int idx_get_UseLayoutRounding = 24;
			internal const int idx_put_UseLayoutRounding = 25;
			internal const int idx_add_KeyUp = 41;
			internal const int idx_remove_KeyUp = 42;
			internal const int idx_add_KeyDown = 43;
			internal const int idx_remove_KeyDown = 44;
			internal const int idx_add_GotFocus = 45;
			internal const int idx_remove_GotFocus = 46;
			internal const int idx_add_LostFocus = 47;
			internal const int idx_remove_LostFocus = 48;
			internal const int idx_add_DragEnter = 49;
			internal const int idx_remove_DragEnter = 50;
			internal const int idx_add_DragLeave = 51;
			internal const int idx_remove_DragLeave = 52;
			internal const int idx_add_DragOver = 53;
			internal const int idx_remove_DragOver = 54;
			internal const int idx_add_Drop = 55;
			internal const int idx_remove_Drop = 56;
			internal const int idx_add_PointerPressed = 57;
			internal const int idx_remove_PointerPressed = 58;
			internal const int idx_add_PointerMoved = 59;
			internal const int idx_remove_PointerMoved = 60;
			internal const int idx_add_PointerReleased = 61;
			internal const int idx_remove_PointerReleased = 62;
			internal const int idx_add_PointerEntered = 63;
			internal const int idx_remove_PointerEntered = 64;
			internal const int idx_add_PointerExited = 65;
			internal const int idx_remove_PointerExited = 66;
			internal const int idx_add_PointerCaptureLost = 67;
			internal const int idx_remove_PointerCaptureLost = 68;
			internal const int idx_add_PointerCanceled = 69;
			internal const int idx_remove_PointerCanceled = 70;
			internal const int idx_add_PointerWheelChanged = 71;
			internal const int idx_remove_PointerWheelChanged = 72;
			internal const int idx_add_Tapped = 73;
			internal const int idx_remove_Tapped = 74;
			internal const int idx_add_DoubleTapped = 75;
			internal const int idx_remove_DoubleTapped = 76;
			internal const int idx_add_Holding = 77;
			internal const int idx_remove_Holding = 78;
			internal const int idx_add_RightTapped = 79;
			internal const int idx_remove_RightTapped = 80;
			internal const int idx_add_ManipulationStarting = 81;
			internal const int idx_remove_ManipulationStarting = 82;
			internal const int idx_add_ManipulationInertiaStarting = 83;
			internal const int idx_remove_ManipulationInertiaStarting = 84;
			internal const int idx_add_ManipulationStarted = 85;
			internal const int idx_remove_ManipulationStarted = 86;
			internal const int idx_add_ManipulationDelta = 87;
			internal const int idx_remove_ManipulationDelta = 88;
			internal const int idx_add_ManipulationCompleted = 89;
			internal const int idx_remove_ManipulationCompleted = 90;
		}
	}

	// Windows.UI.Xaml.IRoutedEventArgs
	public unsafe static class IRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.RoutedEventHandler
	public unsafe static class RoutedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.RoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.RoutedEventHandler, global::Windows.UI.Xaml.RoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.RoutedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.RoutedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__RoutedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__RoutedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl.Windows_UI_Xaml_RoutedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_RoutedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__RoutedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget38>(global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.IRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.RoutedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.RoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_RoutedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.RoutedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_RoutedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.DragEventHandler
	public unsafe static class DragEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.DragEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.DragEventHandler, global::Windows.UI.Xaml.DragEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.DragEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.DragEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__DragEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__DragEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl.Windows_UI_Xaml_DragEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_DragEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__DragEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget39>(global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.IDragEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.DragEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.DragEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_DragEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.DragEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_DragEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IDragEventArgs
	public unsafe static class IDragEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDragEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDragEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDragEventArgs2
	public unsafe static class IDragEventArgs2__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDragEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDragEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDragEventArgs3
	public unsafe static class IDragEventArgs3__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDragEventArgs3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDragEventArgs3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IUIElementOverrides
	public unsafe static class IUIElementOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IUIElementOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeer OnCreateAutomationPeer(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.IUIElementOverrides, global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>(
									__this, 
									global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl.idx_OnCreateAutomationPeer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDisconnectVisualChildren(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.IUIElementOverrides>(
									__this, 
									global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl.idx_OnDisconnectVisualChildren
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElementOverrides.FindSubElementsForTouchTargeting, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Rect__Windows_Foundation__Rect, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] System_Collections_Generic_IEnumerable_1_System_Collections_Generic_IEnumerable_1_Windows_Foundation_Point____Windows_Foundation_Collections__IIterable_A_Windows_Foundation_Collections_IIterable_A_Windows_Foundation_Point_V__V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>> FindSubElementsForTouchTargeting(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point point, 
						global::Windows.Foundation.Rect boundingRect)
			{
				// Setup
				global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl** unsafe_returnValue__retval = default(global::System.Collections.Generic.IEnumerable_A_System_Collections_Generic_IEnumerable_A_Windows_Foundation_Point_V__V___Impl.Vtbl**);
				global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>> returnValue__retval = default(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_returnValue__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElementOverrides).TypeHandle, 
										global::Windows.UI.Xaml.IUIElementOverrides__Impl.Vtbl.idx_FindSubElementsForTouchTargeting, 
										point, 
										boundingRect, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = (global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_returnValue__retval), 
										typeof(global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>>).TypeHandle
									);
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_returnValue__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IUIElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElementOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IUIElementOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::Windows.UI.Xaml.IUIElementOverrides.OnCreateAutomationPeer()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __retVal = global::Windows.UI.Xaml.IUIElementOverrides__Impl.StubClass.OnCreateAutomationPeer(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IUIElementOverrides.OnDisconnectVisualChildren()
			{
				global::Windows.UI.Xaml.IUIElementOverrides__Impl.StubClass.OnDisconnectVisualChildren(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>> global::Windows.UI.Xaml.IUIElementOverrides.FindSubElementsForTouchTargeting(
						global::Windows.Foundation.Point point, 
						global::Windows.Foundation.Rect boundingRect)
			{
				global::System.Collections.Generic.IEnumerable<global::System.Collections.Generic.IEnumerable<global::Windows.Foundation.Point>> __retVal = global::Windows.UI.Xaml.IUIElementOverrides__Impl.StubClass.FindSubElementsForTouchTargeting(
									this, 
									point, 
									boundingRect
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.IUIElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElementOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnCreateAutomationPeer = 6;
			internal const int idx_OnDisconnectVisualChildren = 7;
			internal const int idx_FindSubElementsForTouchTargeting = 8;
		}
	}

	// Windows.UI.Xaml.IUIElement2
	public unsafe static class IUIElement2__Impl
	{
		// v-table for 'Windows.UI.Xaml.IUIElement2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IUIElement3
	public unsafe static class IUIElement3__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IUIElement3'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IUIElement3.add_DragStarting, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_DragStartingEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DragStarting(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget50>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DragStartingEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement3).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl.idx_add_DragStarting, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DragStarting(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl.idx_remove_DragStarting
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement3.add_DropCompleted, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_DropCompletedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DropCompleted(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget51>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_DropCompletedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement3).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl.idx_add_DropCompleted, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DropCompleted(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement3__Impl.Vtbl.idx_remove_DropCompleted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IUIElement3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement3))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IUIElement3
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement3.DragStarting")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement3.add_DragStarting(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DragStartingEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement3__Impl.StubClass.add_DragStarting(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement3.DragStarting")]
			void global::Windows.UI.Xaml.IUIElement3.remove_DragStarting(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement3__Impl.StubClass.remove_DragStarting(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement3.DropCompleted")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement3.add_DropCompleted(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.DropCompletedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement3__Impl.StubClass.add_DropCompleted(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement3.DropCompleted")]
			void global::Windows.UI.Xaml.IUIElement3.remove_DropCompleted(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement3__Impl.StubClass.remove_DropCompleted(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IUIElement3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement3))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_DragStarting = 10;
			internal const int idx_remove_DragStarting = 11;
			internal const int idx_add_DropCompleted = 12;
			internal const int idx_remove_DropCompleted = 13;
		}
	}

	// Windows.UI.Xaml.IDragStartingEventArgs
	public unsafe static class IDragStartingEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDragStartingEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDragStartingEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDragStartingEventArgs2
	public unsafe static class IDragStartingEventArgs2__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDragStartingEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDragStartingEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDropCompletedEventArgs
	public unsafe static class IDropCompletedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDropCompletedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDropCompletedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IUIElement4
	public unsafe static class IUIElement4__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IUIElement4'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IUIElement4.add_ContextRequested, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_Input_ContextRequestedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ContextRequested(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget54>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_ContextRequestedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_add_ContextRequested, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ContextRequested(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_remove_ContextRequested
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement4.add_ContextCanceled, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_RoutedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ContextCanceled(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget55>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_RoutedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_add_ContextCanceled, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ContextCanceled(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_remove_ContextCanceled
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement4.add_AccessKeyDisplayRequested, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_AccessKeyDisplayRequested(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget56>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayRequestedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_add_AccessKeyDisplayRequested, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_AccessKeyDisplayRequested(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_remove_AccessKeyDisplayRequested
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement4.add_AccessKeyDisplayDismissed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_AccessKeyDisplayDismissed(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget57>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyDisplayDismissedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_add_AccessKeyDisplayDismissed, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_AccessKeyDisplayDismissed(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_remove_AccessKeyDisplayDismissed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IUIElement4.add_AccessKeyInvoked, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_UIElement__Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_AccessKeyInvoked(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget58>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_UIElement_j_Windows_UI_Xaml_Input_AccessKeyInvokedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IUIElement4).TypeHandle, 
										global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_add_AccessKeyInvoked, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_AccessKeyInvoked(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IUIElement4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IUIElement4__Impl.Vtbl.idx_remove_AccessKeyInvoked
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IUIElement4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement4))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IUIElement4
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement4.ContextRequested")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement4.add_ContextRequested(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.ContextRequestedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.add_ContextRequested(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement4.ContextRequested")]
			void global::Windows.UI.Xaml.IUIElement4.remove_ContextRequested(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.remove_ContextRequested(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement4.ContextCanceled")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement4.add_ContextCanceled(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.RoutedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.add_ContextCanceled(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement4.ContextCanceled")]
			void global::Windows.UI.Xaml.IUIElement4.remove_ContextCanceled(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.remove_ContextCanceled(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement4.AccessKeyDisplayRequested")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement4.add_AccessKeyDisplayRequested(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.add_AccessKeyDisplayRequested(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement4.AccessKeyDisplayRequested")]
			void global::Windows.UI.Xaml.IUIElement4.remove_AccessKeyDisplayRequested(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.remove_AccessKeyDisplayRequested(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement4.AccessKeyDisplayDismissed")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement4.add_AccessKeyDisplayDismissed(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.add_AccessKeyDisplayDismissed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement4.AccessKeyDisplayDismissed")]
			void global::Windows.UI.Xaml.IUIElement4.remove_AccessKeyDisplayDismissed(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.remove_AccessKeyDisplayDismissed(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IUIElement4.AccessKeyInvoked")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IUIElement4.add_AccessKeyInvoked(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.UIElement, global::Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.add_AccessKeyInvoked(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IUIElement4.AccessKeyInvoked")]
			void global::Windows.UI.Xaml.IUIElement4.remove_AccessKeyInvoked(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IUIElement4__Impl.StubClass.remove_AccessKeyInvoked(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IUIElement4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IUIElement4))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_ContextRequested = 16;
			internal const int idx_remove_ContextRequested = 17;
			internal const int idx_add_ContextCanceled = 18;
			internal const int idx_remove_ContextCanceled = 19;
			internal const int idx_add_AccessKeyDisplayRequested = 20;
			internal const int idx_remove_AccessKeyDisplayRequested = 21;
			internal const int idx_add_AccessKeyDisplayDismissed = 22;
			internal const int idx_remove_AccessKeyDisplayDismissed = 23;
			internal const int idx_add_AccessKeyInvoked = 24;
			internal const int idx_remove_AccessKeyInvoked = 25;
		}
	}

	// Windows.UI.Xaml.IResourceDictionary
	public unsafe static class IResourceDictionary__Impl
	{
		// v-table for 'Windows.UI.Xaml.IResourceDictionary'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IResourceDictionary))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IFrameworkElement
	public unsafe static class IFrameworkElement__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IFrameworkElement'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.ResourceDictionary get_Resources(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.ResourceDictionary __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.IFrameworkElement, global::Windows.UI.Xaml.ResourceDictionary>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_Resources
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Resources(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.ResourceDictionary value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IFrameworkElement, global::Windows.UI.Xaml.ResourceDictionary>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_Resources
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_Width(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_Width
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Width(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_Width
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_Height(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_Height
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Height(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_Height
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IFrameworkElement.get_HorizontalAlignment, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_HorizontalAlignment__Windows_UI_Xaml__HorizontalAlignment, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.HorizontalAlignment get_HorizontalAlignment(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.HorizontalAlignment unsafe_value__retval;
				global::Windows.UI.Xaml.HorizontalAlignment value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IFrameworkElement).TypeHandle, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_HorizontalAlignment, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_HorizontalAlignment(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.HorizontalAlignment value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_HorizontalAlignment
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IFrameworkElement.get_VerticalAlignment, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_VerticalAlignment__Windows_UI_Xaml__VerticalAlignment, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.VerticalAlignment get_VerticalAlignment(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.VerticalAlignment unsafe_value__retval;
				global::Windows.UI.Xaml.VerticalAlignment value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IFrameworkElement).TypeHandle, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_VerticalAlignment, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_VerticalAlignment(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.VerticalAlignment value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_VerticalAlignment
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Thickness get_Margin(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Thickness __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Thickness__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_Margin
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Margin(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Thickness value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_UI_Xaml_Thickness__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_Margin
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Name(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_Name
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.IFrameworkElement.get_FlowDirection, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_FlowDirection__Windows_UI_Xaml__FlowDirection, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.FlowDirection get_FlowDirection(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.FlowDirection unsafe_value__retval;
				global::Windows.UI.Xaml.FlowDirection value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IFrameworkElement).TypeHandle, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_get_FlowDirection, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FlowDirection(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.FlowDirection value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_put_FlowDirection
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Loaded(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_add_Loaded
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Loaded(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_remove_Loaded
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Unloaded(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_add_Unloaded
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Unloaded(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_remove_Unloaded
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IFrameworkElement.add_SizeChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_SizeChangedEventHandler__Windows_UI_Xaml__SizeChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_SizeChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.SizeChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.SizeChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget64>(global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IFrameworkElement).TypeHandle, 
										global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_add_SizeChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_SizeChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_remove_SizeChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_LayoutUpdated(
						global::System.__ComObject __this, 
						global::System.EventHandler<object> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_EventHandler_1_object__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_add_LayoutUpdated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_LayoutUpdated(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement__Impl.Vtbl.idx_remove_LayoutUpdated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IFrameworkElement'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IFrameworkElement
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.Resources")]
			global::Windows.UI.Xaml.ResourceDictionary global::Windows.UI.Xaml.IFrameworkElement.get_Resources()
			{
				global::Windows.UI.Xaml.ResourceDictionary __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_Resources(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.Resources")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_Resources(global::Windows.UI.Xaml.ResourceDictionary value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_Resources(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.Width")]
			double global::Windows.UI.Xaml.IFrameworkElement.get_Width()
			{
				double __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_Width(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.Width")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_Width(double value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_Width(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.Height")]
			double global::Windows.UI.Xaml.IFrameworkElement.get_Height()
			{
				double __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_Height(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.Height")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_Height(double value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_Height(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.HorizontalAlignment")]
			global::Windows.UI.Xaml.HorizontalAlignment global::Windows.UI.Xaml.IFrameworkElement.get_HorizontalAlignment()
			{
				global::Windows.UI.Xaml.HorizontalAlignment __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_HorizontalAlignment(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.HorizontalAlignment")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_HorizontalAlignment(global::Windows.UI.Xaml.HorizontalAlignment value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_HorizontalAlignment(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.VerticalAlignment")]
			global::Windows.UI.Xaml.VerticalAlignment global::Windows.UI.Xaml.IFrameworkElement.get_VerticalAlignment()
			{
				global::Windows.UI.Xaml.VerticalAlignment __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_VerticalAlignment(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.VerticalAlignment")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_VerticalAlignment(global::Windows.UI.Xaml.VerticalAlignment value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_VerticalAlignment(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.Margin")]
			global::Windows.UI.Xaml.Thickness global::Windows.UI.Xaml.IFrameworkElement.get_Margin()
			{
				global::Windows.UI.Xaml.Thickness __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_Margin(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.Margin")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_Margin(global::Windows.UI.Xaml.Thickness value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_Margin(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.Name")]
			string global::Windows.UI.Xaml.IFrameworkElement.get_Name()
			{
				string __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_Name(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement.FlowDirection")]
			global::Windows.UI.Xaml.FlowDirection global::Windows.UI.Xaml.IFrameworkElement.get_FlowDirection()
			{
				global::Windows.UI.Xaml.FlowDirection __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.get_FlowDirection(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement.FlowDirection")]
			void global::Windows.UI.Xaml.IFrameworkElement.put_FlowDirection(global::Windows.UI.Xaml.FlowDirection value)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.put_FlowDirection(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement.Loaded")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement.add_Loaded(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.add_Loaded(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement.Loaded")]
			void global::Windows.UI.Xaml.IFrameworkElement.remove_Loaded(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.remove_Loaded(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement.Unloaded")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement.add_Unloaded(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.add_Unloaded(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement.Unloaded")]
			void global::Windows.UI.Xaml.IFrameworkElement.remove_Unloaded(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.remove_Unloaded(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement.SizeChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement.add_SizeChanged(global::Windows.UI.Xaml.SizeChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.add_SizeChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement.SizeChanged")]
			void global::Windows.UI.Xaml.IFrameworkElement.remove_SizeChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.remove_SizeChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement.LayoutUpdated")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement.add_LayoutUpdated(global::System.EventHandler<object> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.add_LayoutUpdated(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement.LayoutUpdated")]
			void global::Windows.UI.Xaml.IFrameworkElement.remove_LayoutUpdated(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement__Impl.StubClass.remove_LayoutUpdated(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IFrameworkElement'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Resources = 7;
			internal const int idx_put_Resources = 8;
			internal const int idx_get_Width = 15;
			internal const int idx_put_Width = 16;
			internal const int idx_get_Height = 17;
			internal const int idx_put_Height = 18;
			internal const int idx_get_HorizontalAlignment = 27;
			internal const int idx_put_HorizontalAlignment = 28;
			internal const int idx_get_VerticalAlignment = 29;
			internal const int idx_put_VerticalAlignment = 30;
			internal const int idx_get_Margin = 31;
			internal const int idx_put_Margin = 32;
			internal const int idx_get_Name = 33;
			internal const int idx_get_FlowDirection = 41;
			internal const int idx_put_FlowDirection = 42;
			internal const int idx_add_Loaded = 43;
			internal const int idx_remove_Loaded = 44;
			internal const int idx_add_Unloaded = 45;
			internal const int idx_remove_Unloaded = 46;
			internal const int idx_add_SizeChanged = 47;
			internal const int idx_remove_SizeChanged = 48;
			internal const int idx_add_LayoutUpdated = 49;
			internal const int idx_remove_LayoutUpdated = 50;
		}
	}

	// Windows.UI.Xaml.SizeChangedEventHandler
	public unsafe static class SizeChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.SizeChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.SizeChangedEventHandler, global::Windows.UI.Xaml.SizeChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.SizeChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.SizeChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__SizeChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__SizeChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_SizeChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_SizeChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__SizeChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget65>(global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.ISizeChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.SizeChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.SizeChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_SizeChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.SizeChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_SizeChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.ISizeChangedEventArgs
	public unsafe static class ISizeChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.ISizeChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.ISizeChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IFrameworkElementOverrides
	public unsafe static class IFrameworkElementOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IFrameworkElementOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Size MeasureOverride(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Size availableSize)
			{
				global::Windows.Foundation.Size __ret = global::McgInterop.ForwardComSharedStubs.Func__Size___Size__<global::Windows.UI.Xaml.IFrameworkElementOverrides>(
									__this, 
									availableSize, 
									global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.Vtbl.idx_MeasureOverride
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Size ArrangeOverride(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Size finalSize)
			{
				global::Windows.Foundation.Size __ret = global::McgInterop.ForwardComSharedStubs.Func__Size___Size__<global::Windows.UI.Xaml.IFrameworkElementOverrides>(
									__this, 
									finalSize, 
									global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.Vtbl.idx_ArrangeOverride
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnApplyTemplate(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.IFrameworkElementOverrides>(
									__this, 
									global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.Vtbl.idx_OnApplyTemplate
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IFrameworkElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElementOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IFrameworkElementOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.Size global::Windows.UI.Xaml.IFrameworkElementOverrides.MeasureOverride(global::Windows.Foundation.Size availableSize)
			{
				global::Windows.Foundation.Size __retVal = global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.StubClass.MeasureOverride(
									this, 
									availableSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.Size global::Windows.UI.Xaml.IFrameworkElementOverrides.ArrangeOverride(global::Windows.Foundation.Size finalSize)
			{
				global::Windows.Foundation.Size __retVal = global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.StubClass.ArrangeOverride(
									this, 
									finalSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IFrameworkElementOverrides.OnApplyTemplate()
			{
				global::Windows.UI.Xaml.IFrameworkElementOverrides__Impl.StubClass.OnApplyTemplate(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IFrameworkElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElementOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_MeasureOverride = 6;
			internal const int idx_ArrangeOverride = 7;
			internal const int idx_OnApplyTemplate = 8;
		}
	}

	// Windows.UI.Xaml.IFrameworkElement2
	public unsafe static class IFrameworkElement2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IFrameworkElement2'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IFrameworkElement2.get_RequestedTheme, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_ElementTheme__Windows_UI_Xaml__ElementTheme, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.ElementTheme get_RequestedTheme(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.ElementTheme unsafe_value__retval;
				global::Windows.UI.Xaml.ElementTheme value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.IFrameworkElement2).TypeHandle, 
									global::Windows.UI.Xaml.IFrameworkElement2__Impl.Vtbl.idx_get_RequestedTheme, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_RequestedTheme(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.ElementTheme value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.IFrameworkElement2>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.IFrameworkElement2__Impl.Vtbl.idx_put_RequestedTheme
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IFrameworkElement2.add_DataContextChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_FrameworkElement__Windows_UI_Xaml_DataContextChangedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DataContextChanged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget66>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_Windows_UI_Xaml_DataContextChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IFrameworkElement2).TypeHandle, 
										global::Windows.UI.Xaml.IFrameworkElement2__Impl.Vtbl.idx_add_DataContextChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DataContextChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement2>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement2__Impl.Vtbl.idx_remove_DataContextChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IFrameworkElement2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IFrameworkElement2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IFrameworkElement2.RequestedTheme")]
			global::Windows.UI.Xaml.ElementTheme global::Windows.UI.Xaml.IFrameworkElement2.get_RequestedTheme()
			{
				global::Windows.UI.Xaml.ElementTheme __retVal = global::Windows.UI.Xaml.IFrameworkElement2__Impl.StubClass.get_RequestedTheme(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IFrameworkElement2.RequestedTheme")]
			void global::Windows.UI.Xaml.IFrameworkElement2.put_RequestedTheme(global::Windows.UI.Xaml.ElementTheme value)
			{
				global::Windows.UI.Xaml.IFrameworkElement2__Impl.StubClass.put_RequestedTheme(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement2.DataContextChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement2.add_DataContextChanged(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, global::Windows.UI.Xaml.DataContextChangedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement2__Impl.StubClass.add_DataContextChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement2.DataContextChanged")]
			void global::Windows.UI.Xaml.IFrameworkElement2.remove_DataContextChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement2__Impl.StubClass.remove_DataContextChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IFrameworkElement2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_RequestedTheme = 6;
			internal const int idx_put_RequestedTheme = 7;
			internal const int idx_add_DataContextChanged = 8;
			internal const int idx_remove_DataContextChanged = 9;
		}
	}

	// Windows.UI.Xaml.IDataContextChangedEventArgs
	public unsafe static class IDataContextChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDataContextChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDataContextChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IFrameworkElementOverrides2
	public unsafe static class IFrameworkElementOverrides2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IFrameworkElementOverrides2'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IFrameworkElementOverrides2.GoToElementStateCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, [fwd] [in] [Mcg.CodeGen.CBoolMarshaller] bool__bool, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool GoToElementStateCore(
						global::System.__ComObject __this, 
						string stateName, 
						bool useTransitions)
			{
				// Setup
				global::System.Runtime.InteropServices.HSTRING unsafe_stateName = default(global::System.Runtime.InteropServices.HSTRING);
				sbyte unsafe_useTransitions;
				bool returnValue__retval;
				sbyte unsafe_returnValue__retval;
				int unsafe___return__;
				// Marshalling
				fixed (char* pBuffer_stateName = stateName)
				{
					global::System.Runtime.InteropServices.HSTRING_HEADER hstring_header_stateName;
					global::System.Runtime.InteropServices.McgMarshal.StringToHStringReference(pBuffer_stateName, stateName, &(hstring_header_stateName), &(unsafe_stateName));
					unsafe_useTransitions = (useTransitions ? ((sbyte)1) : ((sbyte)0));
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IFrameworkElementOverrides2).TypeHandle, 
										global::Windows.UI.Xaml.IFrameworkElementOverrides2__Impl.Vtbl.idx_GoToElementStateCore, 
										unsafe_stateName, 
										unsafe_useTransitions, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = unsafe_returnValue__retval != 0;
				}
				// Return
				return returnValue__retval;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IFrameworkElementOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElementOverrides2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IFrameworkElementOverrides2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.IFrameworkElementOverrides2.GoToElementStateCore(
						string stateName, 
						bool useTransitions)
			{
				bool __retVal = global::Windows.UI.Xaml.IFrameworkElementOverrides2__Impl.StubClass.GoToElementStateCore(
									this, 
									stateName, 
									useTransitions
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.IFrameworkElementOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElementOverrides2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GoToElementStateCore = 6;
		}
	}

	// Windows.UI.Xaml.IFrameworkElement3
	public unsafe static class IFrameworkElement3__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IFrameworkElement3'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.IFrameworkElement3.add_Loading, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_FrameworkElement__object___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_object_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Loading(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget68>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_FrameworkElement_j_System_Object_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IFrameworkElement3).TypeHandle, 
										global::Windows.UI.Xaml.IFrameworkElement3__Impl.Vtbl.idx_add_Loading, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Loading(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IFrameworkElement3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IFrameworkElement3__Impl.Vtbl.idx_remove_Loading
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IFrameworkElement3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement3))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IFrameworkElement3
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IFrameworkElement3.Loading")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IFrameworkElement3.add_Loading(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.FrameworkElement, object> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IFrameworkElement3__Impl.StubClass.add_Loading(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IFrameworkElement3.Loading")]
			void global::Windows.UI.Xaml.IFrameworkElement3.remove_Loading(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IFrameworkElement3__Impl.StubClass.remove_Loading(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IFrameworkElement3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement3))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_Loading = 6;
			internal const int idx_remove_Loading = 7;
		}
	}

	// Windows.UI.Xaml.IFrameworkElement4
	public unsafe static class IFrameworkElement4__Impl
	{
		// v-table for 'Windows.UI.Xaml.IFrameworkElement4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkElement4))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.DependencyPropertyChangedEventHandler
	public unsafe static class DependencyPropertyChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler, global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.DependencyPropertyChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__DependencyPropertyChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__DependencyPropertyChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_DependencyPropertyChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_DependencyPropertyChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__DependencyPropertyChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget71>(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.IDependencyPropertyChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.DependencyPropertyChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_DependencyPropertyChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_DependencyPropertyChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IDependencyPropertyChangedEventArgs
	public unsafe static class IDependencyPropertyChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDependencyPropertyChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDependencyPropertyChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IFrameworkTemplate
	public unsafe static class IFrameworkTemplate__Impl
	{
		// v-table for 'Windows.UI.Xaml.IFrameworkTemplate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IFrameworkTemplate))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IDataTemplate
	public unsafe static class IDataTemplate__Impl
	{
		// v-table for 'Windows.UI.Xaml.IDataTemplate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IDataTemplate))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.ExceptionRoutedEventHandler
	public unsafe static class ExceptionRoutedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.ExceptionRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.ExceptionRoutedEventHandler, global::Windows.UI.Xaml.ExceptionRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.ExceptionRoutedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.ExceptionRoutedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__ExceptionRoutedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__ExceptionRoutedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl.Windows_UI_Xaml_ExceptionRoutedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_ExceptionRoutedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__ExceptionRoutedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget99>(global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.IExceptionRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.ExceptionRoutedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.ExceptionRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_ExceptionRoutedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_ExceptionRoutedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IExceptionRoutedEventArgs
	public unsafe static class IExceptionRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.IExceptionRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IExceptionRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.IWindowStatics
	public unsafe static class IWindowStatics__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IWindowStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Window get_Current(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Window __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.IWindowStatics, global::Windows.UI.Xaml.Window>(
									__this, 
									global::Windows.UI.Xaml.IWindowStatics__Impl.Vtbl.idx_get_Current
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IWindowStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindowStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IWindowStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IWindowStatics.Current")]
			global::Windows.UI.Xaml.Window global::Windows.UI.Xaml.IWindowStatics.get_Current()
			{
				global::Windows.UI.Xaml.Window __retVal = global::Windows.UI.Xaml.IWindowStatics__Impl.StubClass.get_Current(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.IWindowStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindowStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Current = 6;
		}
	}

	// Windows.UI.Xaml.IWindow
	public unsafe static class IWindow__Impl
	{
		// StubClass for 'Windows.UI.Xaml.IWindow'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.UIElement get_Content(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.UIElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.IWindow, global::Windows.UI.Xaml.UIElement>(
									__this, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_get_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Content(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.UIElement value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.IWindow, global::Windows.UI.Xaml.UIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_put_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IWindow.add_Activated, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_WindowActivatedEventHandler__Windows_UI_Xaml__WindowActivatedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Activated(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.WindowActivatedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.WindowActivatedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget148>(global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IWindow).TypeHandle, 
										global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_add_Activated, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Activated(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IWindow>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_remove_Activated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IWindow.add_Closed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_WindowClosedEventHandler__Windows_UI_Xaml__WindowClosedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Closed(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.WindowClosedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.WindowClosedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget149>(global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IWindow).TypeHandle, 
										global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_add_Closed, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Closed(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IWindow>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_remove_Closed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IWindow.add_SizeChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_WindowSizeChangedEventHandler__Windows_UI_Xaml__WindowSizeChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_SizeChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.WindowSizeChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.WindowSizeChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget150>(global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IWindow).TypeHandle, 
										global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_add_SizeChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_SizeChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IWindow>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_remove_SizeChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.IWindow.add_VisibilityChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_WindowVisibilityChangedEventHandler__Windows_UI_Xaml__WindowVisibilityChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_VisibilityChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget151>(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.IWindow).TypeHandle, 
										global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_add_VisibilityChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_VisibilityChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.IWindow>(
									__this, 
									token, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_remove_VisibilityChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void Activate(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.IWindow>(
									__this, 
									global::Windows.UI.Xaml.IWindow__Impl.Vtbl.idx_Activate
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.IWindow'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindow))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.IWindow
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.IWindow.Content")]
			global::Windows.UI.Xaml.UIElement global::Windows.UI.Xaml.IWindow.get_Content()
			{
				global::Windows.UI.Xaml.UIElement __retVal = global::Windows.UI.Xaml.IWindow__Impl.StubClass.get_Content(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.IWindow.Content")]
			void global::Windows.UI.Xaml.IWindow.put_Content(global::Windows.UI.Xaml.UIElement value)
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.put_Content(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IWindow.Activated")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IWindow.add_Activated(global::Windows.UI.Xaml.WindowActivatedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IWindow__Impl.StubClass.add_Activated(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IWindow.Activated")]
			void global::Windows.UI.Xaml.IWindow.remove_Activated(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.remove_Activated(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IWindow.Closed")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IWindow.add_Closed(global::Windows.UI.Xaml.WindowClosedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IWindow__Impl.StubClass.add_Closed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IWindow.Closed")]
			void global::Windows.UI.Xaml.IWindow.remove_Closed(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.remove_Closed(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IWindow.SizeChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IWindow.add_SizeChanged(global::Windows.UI.Xaml.WindowSizeChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IWindow__Impl.StubClass.add_SizeChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IWindow.SizeChanged")]
			void global::Windows.UI.Xaml.IWindow.remove_SizeChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.remove_SizeChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.IWindow.VisibilityChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.IWindow.add_VisibilityChanged(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.IWindow__Impl.StubClass.add_VisibilityChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.IWindow.VisibilityChanged")]
			void global::Windows.UI.Xaml.IWindow.remove_VisibilityChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.remove_VisibilityChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.IWindow.Activate()
			{
				global::Windows.UI.Xaml.IWindow__Impl.StubClass.Activate(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.IWindow'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindow))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Content = 8;
			internal const int idx_put_Content = 9;
			internal const int idx_add_Activated = 12;
			internal const int idx_remove_Activated = 13;
			internal const int idx_add_Closed = 14;
			internal const int idx_remove_Closed = 15;
			internal const int idx_add_SizeChanged = 16;
			internal const int idx_remove_SizeChanged = 17;
			internal const int idx_add_VisibilityChanged = 18;
			internal const int idx_remove_VisibilityChanged = 19;
			internal const int idx_Activate = 20;
		}
	}

	// Windows.UI.Xaml.WindowActivatedEventHandler
	public unsafe static class WindowActivatedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Core.WindowActivatedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.WindowActivatedEventHandler, global::Windows.UI.Core.WindowActivatedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.WindowActivatedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.WindowActivatedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__WindowActivatedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__WindowActivatedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl.Windows_UI_Xaml_WindowActivatedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_WindowActivatedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__WindowActivatedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget152>(global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Core.IWindowActivatedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.WindowActivatedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Core.WindowActivatedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_WindowActivatedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.WindowActivatedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_WindowActivatedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.WindowClosedEventHandler
	public unsafe static class WindowClosedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Core.CoreWindowEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.WindowClosedEventHandler, global::Windows.UI.Core.CoreWindowEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.WindowClosedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.WindowClosedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__WindowClosedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__WindowClosedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl.Windows_UI_Xaml_WindowClosedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_WindowClosedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__WindowClosedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget153>(global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Core.ICoreWindowEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.WindowClosedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Core.CoreWindowEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_WindowClosedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.WindowClosedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_WindowClosedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.WindowSizeChangedEventHandler
	public unsafe static class WindowSizeChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Core.WindowSizeChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.WindowSizeChangedEventHandler, global::Windows.UI.Core.WindowSizeChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.WindowSizeChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.WindowSizeChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__WindowSizeChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__WindowSizeChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_WindowSizeChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_WindowSizeChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__WindowSizeChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget154>(global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Core.IWindowSizeChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.WindowSizeChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Core.WindowSizeChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_WindowSizeChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.WindowSizeChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_WindowSizeChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.WindowVisibilityChangedEventHandler
	public unsafe static class WindowVisibilityChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Core.VisibilityChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler, global::Windows.UI.Core.VisibilityChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.WindowVisibilityChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml__WindowVisibilityChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml__WindowVisibilityChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_WindowVisibilityChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_WindowVisibilityChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml__WindowVisibilityChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget155>(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Core.IVisibilityChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Core.VisibilityChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_WindowVisibilityChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.WindowVisibilityChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_WindowVisibilityChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.IWindow2
	public unsafe static class IWindow2__Impl
	{
		// v-table for 'Windows.UI.Xaml.IWindow2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.IWindow2))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Xaml.Automation.Peers
{
	// Windows.UI.Xaml.Automation.Peers.IAutomationPeer
	public unsafe static class IAutomationPeer__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeer'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides
	public unsafe static class IAutomationPeerOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object GetPatternCore(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.PatternInterface patternInterface)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_intobject__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									((int)patternInterface), 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetPatternCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetAcceleratorKeyCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetAcceleratorKeyCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetAccessKeyCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetAccessKeyCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetAutomationControlTypeCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationControlType__Windows_UI_Xaml_Automation_Peers__AutomationControlType, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationControlType GetAutomationControlTypeCore(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Automation.Peers.AutomationControlType unsafe_returnValue__retval;
				global::Windows.UI.Xaml.Automation.Peers.AutomationControlType returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetAutomationControlTypeCore, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetAutomationIdCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetAutomationIdCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetBoundingRectangleCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Rect__Windows_Foundation__Rect, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Rect GetBoundingRectangleCore(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.Foundation.Rect unsafe_returnValue__retval;
				global::Windows.Foundation.Rect returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetBoundingRectangleCore, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> GetChildrenCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetChildrenCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetClassNameCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetClassNameCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Point GetClickablePointCore(global::System.__ComObject __this)
			{
				global::Windows.Foundation.Point __ret = global::McgInterop.ForwardComSharedStubs.Func__Point__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetClickablePointCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetHelpTextCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetHelpTextCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetItemStatusCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetItemStatusCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetItemTypeCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetItemTypeCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeer GetLabeledByCore(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides, global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetLabeledByCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetLocalizedControlTypeCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetLocalizedControlTypeCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetNameCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetNameCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetOrientationCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationOrientation__Windows_UI_Xaml_Automation_Peers__AutomationOrientation, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationOrientation GetOrientationCore(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Automation.Peers.AutomationOrientation unsafe_returnValue__retval;
				global::Windows.UI.Xaml.Automation.Peers.AutomationOrientation returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetOrientationCore, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool HasKeyboardFocusCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_HasKeyboardFocusCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsContentElementCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsContentElementCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsControlElementCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsControlElementCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsEnabledCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsEnabledCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsKeyboardFocusableCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsKeyboardFocusableCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsOffscreenCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsOffscreenCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsPasswordCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsPasswordCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsRequiredForFormCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_IsRequiredForFormCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void SetFocusCore(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_SetFocusCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetPeerFromPointCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationPeer__Windows_UI_Xaml_Automation_Peers__AutomationPeer *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeer GetPeerFromPointCore(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point point)
			{
				// Setup
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl** unsafe_returnValue__retval = default(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer__Impl.Vtbl**);
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer returnValue__retval = default(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_returnValue__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle, 
										global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetPeerFromPointCore, 
										point, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = (global::Windows.UI.Xaml.Automation.Peers.AutomationPeer)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_returnValue__retval), 
										typeof(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer).TypeHandle
									);
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_returnValue__retval)));
				}
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetLiveSettingCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationLiveSetting__Windows_UI_Xaml_Automation_Peers__AutomationLiveSetting, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationLiveSetting GetLiveSettingCore(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Automation.Peers.AutomationLiveSetting unsafe_returnValue__retval;
				global::Windows.UI.Xaml.Automation.Peers.AutomationLiveSetting returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.Vtbl.idx_GetLiveSettingCore, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetPatternCore(global::Windows.UI.Xaml.Automation.Peers.PatternInterface patternInterface)
			{
				object __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetPatternCore(
									this, 
									patternInterface
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetAcceleratorKeyCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetAcceleratorKeyCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetAccessKeyCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetAccessKeyCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationControlType global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetAutomationControlTypeCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationControlType __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetAutomationControlTypeCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetAutomationIdCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetAutomationIdCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.Rect global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetBoundingRectangleCore()
			{
				global::Windows.Foundation.Rect __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetBoundingRectangleCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetChildrenCore()
			{
				global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetChildrenCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetClassNameCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetClassNameCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.Point global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetClickablePointCore()
			{
				global::Windows.Foundation.Point __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetClickablePointCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetHelpTextCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetHelpTextCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetItemStatusCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetItemStatusCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetItemTypeCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetItemTypeCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetLabeledByCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetLabeledByCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetLocalizedControlTypeCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetLocalizedControlTypeCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetNameCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetNameCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationOrientation global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetOrientationCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationOrientation __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetOrientationCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.HasKeyboardFocusCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.HasKeyboardFocusCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsContentElementCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsContentElementCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsControlElementCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsControlElementCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsEnabledCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsEnabledCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsKeyboardFocusableCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsKeyboardFocusableCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsOffscreenCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsOffscreenCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsPasswordCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsPasswordCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.IsRequiredForFormCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.IsRequiredForFormCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.SetFocusCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.SetFocusCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetPeerFromPointCore(global::Windows.Foundation.Point point)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetPeerFromPointCore(
									this, 
									point
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationLiveSetting global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides.GetLiveSettingCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationLiveSetting __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides__Impl.StubClass.GetLiveSettingCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetPatternCore = 6;
			internal const int idx_GetAcceleratorKeyCore = 7;
			internal const int idx_GetAccessKeyCore = 8;
			internal const int idx_GetAutomationControlTypeCore = 9;
			internal const int idx_GetAutomationIdCore = 10;
			internal const int idx_GetBoundingRectangleCore = 11;
			internal const int idx_GetChildrenCore = 12;
			internal const int idx_GetClassNameCore = 13;
			internal const int idx_GetClickablePointCore = 14;
			internal const int idx_GetHelpTextCore = 15;
			internal const int idx_GetItemStatusCore = 16;
			internal const int idx_GetItemTypeCore = 17;
			internal const int idx_GetLabeledByCore = 18;
			internal const int idx_GetLocalizedControlTypeCore = 19;
			internal const int idx_GetNameCore = 20;
			internal const int idx_GetOrientationCore = 21;
			internal const int idx_HasKeyboardFocusCore = 22;
			internal const int idx_IsContentElementCore = 23;
			internal const int idx_IsControlElementCore = 24;
			internal const int idx_IsEnabledCore = 25;
			internal const int idx_IsKeyboardFocusableCore = 26;
			internal const int idx_IsOffscreenCore = 27;
			internal const int idx_IsPasswordCore = 28;
			internal const int idx_IsRequiredForFormCore = 29;
			internal const int idx_SetFocusCore = 30;
			internal const int idx_GetPeerFromPointCore = 31;
			internal const int idx_GetLiveSettingCore = 32;
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected
	public unsafe static class IAutomationPeerProtected__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationPeer PeerFromProvider(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple provider)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected, global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>(
									__this, 
									provider, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl.idx_PeerFromProvider
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple ProviderFromPeer(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationPeer peer)
			{
				global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected, global::Windows.UI.Xaml.Automation.Peers.AutomationPeer, global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple>(
									__this, 
									peer, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.Vtbl.idx_ProviderFromPeer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationPeer global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected.PeerFromProvider(global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple provider)
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationPeer __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.StubClass.PeerFromProvider(
									this, 
									provider
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected.ProviderFromPeer(global::Windows.UI.Xaml.Automation.Peers.AutomationPeer peer)
			{
				global::Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected__Impl.StubClass.ProviderFromPeer(
									this, 
									peer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_PeerFromProvider = 6;
			internal const int idx_ProviderFromPeer = 7;
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeer2
	public unsafe static class IAutomationPeer2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeer2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2
	public unsafe static class IAutomationPeerOverrides2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void ShowContextMenuCore(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl.idx_ShowContextMenuCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> GetControlledPeersCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2, global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.Vtbl.idx_GetControlledPeersCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2.ShowContextMenuCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.StubClass.ShowContextMenuCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2.GetControlledPeersCore()
			{
				global::System.Collections.Generic.IReadOnlyList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2__Impl.StubClass.GetControlledPeersCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_ShowContextMenuCore = 6;
			internal const int idx_GetControlledPeersCore = 7;
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeer3
	public unsafe static class IAutomationPeer3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeer3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3
	public unsafe static class IAutomationPeerOverrides3__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object NavigateCore(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Automation.Peers.AutomationNavigationDirection direction)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_intobject__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									((int)direction), 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_NavigateCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetElementFromPointCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object GetElementFromPointCore(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point pointInWindowCoordinates)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_returnValue__retval = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				object returnValue__retval = default(object);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_returnValue__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3).TypeHandle, 
										global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetElementFromPointCore, 
										pointInWindowCoordinates, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_returnValue__retval));
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_returnValue__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object GetFocusedElementCore(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetFocusedElementCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> GetAnnotationsCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3, global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetAnnotationsCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetPositionInSetCore(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetPositionInSetCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetSizeOfSetCore(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetSizeOfSetCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetLevelCore(global::System.__ComObject __this)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_int__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.Vtbl.idx_GetLevelCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.NavigateCore(global::Windows.UI.Xaml.Automation.Peers.AutomationNavigationDirection direction)
			{
				object __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.NavigateCore(
									this, 
									direction
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetElementFromPointCore(global::Windows.Foundation.Point pointInWindowCoordinates)
			{
				object __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetElementFromPointCore(
									this, 
									pointInWindowCoordinates
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetFocusedElementCore()
			{
				object __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetFocusedElementCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetAnnotationsCore()
			{
				global::System.Collections.Generic.IList<global::Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetAnnotationsCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetPositionInSetCore()
			{
				int __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetPositionInSetCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetSizeOfSetCore()
			{
				int __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetSizeOfSetCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3.GetLevelCore()
			{
				int __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3__Impl.StubClass.GetLevelCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_NavigateCore = 6;
			internal const int idx_GetElementFromPointCore = 7;
			internal const int idx_GetFocusedElementCore = 8;
			internal const int idx_GetAnnotationsCore = 9;
			internal const int idx_GetPositionInSetCore = 10;
			internal const int idx_GetSizeOfSetCore = 11;
			internal const int idx_GetLevelCore = 12;
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation
	public unsafe static class IAutomationPeerAnnotation__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeer4
	public unsafe static class IAutomationPeer4__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeer4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer4))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4
	public unsafe static class IAutomationPeerOverrides4__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4.GetLandmarkTypeCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_Automation_Peers_AutomationLandmarkType__Windows_UI_Xaml_Automation_Peers__AutomationLandmarkType, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Automation.Peers.AutomationLandmarkType GetLandmarkTypeCore(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Automation.Peers.AutomationLandmarkType unsafe_returnValue__retval;
				global::Windows.UI.Xaml.Automation.Peers.AutomationLandmarkType returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4).TypeHandle, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl.idx_GetLandmarkTypeCore, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetLocalizedLandmarkTypeCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.Vtbl.idx_GetLocalizedLandmarkTypeCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Automation.Peers.AutomationLandmarkType global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4.GetLandmarkTypeCore()
			{
				global::Windows.UI.Xaml.Automation.Peers.AutomationLandmarkType __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.StubClass.GetLandmarkTypeCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4.GetLocalizedLandmarkTypeCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4__Impl.StubClass.GetLocalizedLandmarkTypeCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetLandmarkTypeCore = 6;
			internal const int idx_GetLocalizedLandmarkTypeCore = 7;
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeer5
	public unsafe static class IAutomationPeer5__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeer5'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeer5))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5
	public unsafe static class IAutomationPeerOverrides5__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsPeripheralCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_IsPeripheralCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool IsDataValidForFormCore(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_IsDataValidForFormCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string GetFullDescriptionCore(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_GetFullDescriptionCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> GetDescribedByCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_GetDescribedByCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> GetFlowsToCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_GetFlowsToCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> GetFlowsFromCore(global::System.__ComObject __this)
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5, global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer>>(
									__this, 
									global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.Vtbl.idx_GetFlowsFromCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.IsPeripheralCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.IsPeripheralCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.IsDataValidForFormCore()
			{
				bool __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.IsDataValidForFormCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			string global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.GetFullDescriptionCore()
			{
				string __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.GetFullDescriptionCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.GetDescribedByCore()
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.GetDescribedByCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.GetFlowsToCore()
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.GetFlowsToCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5.GetFlowsFromCore()
			{
				global::System.Collections.Generic.IEnumerable<global::Windows.UI.Xaml.Automation.Peers.AutomationPeer> __retVal = global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5__Impl.StubClass.GetFlowsFromCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_IsPeripheralCore = 6;
			internal const int idx_IsDataValidForFormCore = 7;
			internal const int idx_GetFullDescriptionCore = 8;
			internal const int idx_GetDescribedByCore = 9;
			internal const int idx_GetFlowsToCore = 10;
			internal const int idx_GetFlowsFromCore = 11;
		}
	}
}

namespace Windows.UI.Xaml.Automation.Provider
{
	// Windows.UI.Xaml.Automation.Provider.IIRawElementProviderSimple
	public unsafe static class IIRawElementProviderSimple__Impl
	{
		// v-table for 'Windows.UI.Xaml.Automation.Provider.IIRawElementProviderSimple'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Automation.Provider.IIRawElementProviderSimple))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Xaml.Controls
{
	// Windows.UI.Xaml.Controls.IControl
	public unsafe static class IControl__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IControl'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_FontSize(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_FontSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FontSize(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_FontSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.FontFamily get_FontFamily(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.FontFamily __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.FontFamily>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_FontFamily
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FontFamily(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.FontFamily value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.FontFamily>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_FontFamily
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Thickness get_Padding(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Thickness __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_Padding
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Padding(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Thickness value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_Padding
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Brush get_Background(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Brush __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_Background
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Background(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Brush value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_Background
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Thickness get_BorderThickness(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Thickness __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_BorderThickness
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_BorderThickness(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Thickness value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_BorderThickness
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Brush get_BorderBrush(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Brush __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_get_BorderBrush
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_BorderBrush(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Brush value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControl, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_put_BorderBrush
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IControl.add_IsEnabledChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_DependencyPropertyChangedEventHandler__Windows_UI_Xaml__DependencyPropertyChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_IsEnabledChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget70>(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IControl).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_add_IsEnabledChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_IsEnabledChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IControl>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IControl__Impl.Vtbl.idx_remove_IsEnabledChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IControl
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.FontSize")]
			double global::Windows.UI.Xaml.Controls.IControl.get_FontSize()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_FontSize(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.FontSize")]
			void global::Windows.UI.Xaml.Controls.IControl.put_FontSize(double value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_FontSize(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.FontFamily")]
			global::Windows.UI.Xaml.Media.FontFamily global::Windows.UI.Xaml.Controls.IControl.get_FontFamily()
			{
				global::Windows.UI.Xaml.Media.FontFamily __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_FontFamily(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.FontFamily")]
			void global::Windows.UI.Xaml.Controls.IControl.put_FontFamily(global::Windows.UI.Xaml.Media.FontFamily value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_FontFamily(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.Padding")]
			global::Windows.UI.Xaml.Thickness global::Windows.UI.Xaml.Controls.IControl.get_Padding()
			{
				global::Windows.UI.Xaml.Thickness __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_Padding(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.Padding")]
			void global::Windows.UI.Xaml.Controls.IControl.put_Padding(global::Windows.UI.Xaml.Thickness value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_Padding(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.Background")]
			global::Windows.UI.Xaml.Media.Brush global::Windows.UI.Xaml.Controls.IControl.get_Background()
			{
				global::Windows.UI.Xaml.Media.Brush __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_Background(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.Background")]
			void global::Windows.UI.Xaml.Controls.IControl.put_Background(global::Windows.UI.Xaml.Media.Brush value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_Background(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.BorderThickness")]
			global::Windows.UI.Xaml.Thickness global::Windows.UI.Xaml.Controls.IControl.get_BorderThickness()
			{
				global::Windows.UI.Xaml.Thickness __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_BorderThickness(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.BorderThickness")]
			void global::Windows.UI.Xaml.Controls.IControl.put_BorderThickness(global::Windows.UI.Xaml.Thickness value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_BorderThickness(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControl.BorderBrush")]
			global::Windows.UI.Xaml.Media.Brush global::Windows.UI.Xaml.Controls.IControl.get_BorderBrush()
			{
				global::Windows.UI.Xaml.Media.Brush __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.get_BorderBrush(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControl.BorderBrush")]
			void global::Windows.UI.Xaml.Controls.IControl.put_BorderBrush(global::Windows.UI.Xaml.Media.Brush value)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.put_BorderBrush(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IControl.IsEnabledChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IControl.add_IsEnabledChanged(global::Windows.UI.Xaml.DependencyPropertyChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.add_IsEnabledChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IControl.IsEnabledChanged")]
			void global::Windows.UI.Xaml.Controls.IControl.remove_IsEnabledChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IControl__Impl.StubClass.remove_IsEnabledChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_FontSize = 6;
			internal const int idx_put_FontSize = 7;
			internal const int idx_get_FontFamily = 8;
			internal const int idx_put_FontFamily = 9;
			internal const int idx_get_Padding = 30;
			internal const int idx_put_Padding = 31;
			internal const int idx_get_Background = 36;
			internal const int idx_put_Background = 37;
			internal const int idx_get_BorderThickness = 38;
			internal const int idx_put_BorderThickness = 39;
			internal const int idx_get_BorderBrush = 40;
			internal const int idx_put_BorderBrush = 41;
			internal const int idx_add_IsEnabledChanged = 43;
			internal const int idx_remove_IsEnabledChanged = 44;
		}
	}

	// Windows.UI.Xaml.Controls.IControlOverrides
	public unsafe static class IControlOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IControlOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerEntered(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerEntered
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerPressed(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerPressed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerMoved(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerMoved
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerReleased(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerReleased
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerExited(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerExited
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerCaptureLost(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerCaptureLost
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerCanceled(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerCanceled
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnPointerWheelChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnPointerWheelChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnTapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnTapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDoubleTapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnDoubleTapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnHolding(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnHolding
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnRightTapped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnRightTapped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnManipulationStarting(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnManipulationStarting
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnManipulationInertiaStarting(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnManipulationInertiaStarting
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnManipulationStarted(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnManipulationStarted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnManipulationDelta(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnManipulationDelta
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnManipulationCompleted(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnManipulationCompleted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnKeyUp(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnKeyUp
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnKeyDown(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnKeyDown
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnGotFocus(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.RoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnGotFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnLostFocus(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.RoutedEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnLostFocus
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDragEnter(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.DragEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnDragEnter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDragLeave(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.DragEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnDragLeave
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDragOver(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.DragEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnDragOver
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDrop(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IControlOverrides, global::Windows.UI.Xaml.DragEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.Vtbl.idx_OnDrop
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IControlOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControlOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IControlOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerEntered(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerEntered(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerPressed(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerPressed(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerMoved(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerMoved(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerReleased(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerReleased(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerExited(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerExited(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerCaptureLost(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerCaptureLost(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerCanceled(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerCanceled(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnPointerWheelChanged(global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnPointerWheelChanged(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnTapped(global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnTapped(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnDoubleTapped(global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnDoubleTapped(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnHolding(global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnHolding(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnRightTapped(global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnRightTapped(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnManipulationStarting(global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnManipulationStarting(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnManipulationInertiaStarting(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnManipulationInertiaStarting(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnManipulationStarted(global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnManipulationStarted(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnManipulationDelta(global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnManipulationDelta(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnManipulationCompleted(global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnManipulationCompleted(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnKeyUp(global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnKeyUp(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnKeyDown(global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnKeyDown(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnGotFocus(global::Windows.UI.Xaml.RoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnGotFocus(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnLostFocus(global::Windows.UI.Xaml.RoutedEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnLostFocus(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnDragEnter(global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnDragEnter(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnDragLeave(global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnDragLeave(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnDragOver(global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnDragOver(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IControlOverrides.OnDrop(global::Windows.UI.Xaml.DragEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IControlOverrides__Impl.StubClass.OnDrop(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IControlOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControlOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnPointerEntered = 6;
			internal const int idx_OnPointerPressed = 7;
			internal const int idx_OnPointerMoved = 8;
			internal const int idx_OnPointerReleased = 9;
			internal const int idx_OnPointerExited = 10;
			internal const int idx_OnPointerCaptureLost = 11;
			internal const int idx_OnPointerCanceled = 12;
			internal const int idx_OnPointerWheelChanged = 13;
			internal const int idx_OnTapped = 14;
			internal const int idx_OnDoubleTapped = 15;
			internal const int idx_OnHolding = 16;
			internal const int idx_OnRightTapped = 17;
			internal const int idx_OnManipulationStarting = 18;
			internal const int idx_OnManipulationInertiaStarting = 19;
			internal const int idx_OnManipulationStarted = 20;
			internal const int idx_OnManipulationDelta = 21;
			internal const int idx_OnManipulationCompleted = 22;
			internal const int idx_OnKeyUp = 23;
			internal const int idx_OnKeyDown = 24;
			internal const int idx_OnGotFocus = 25;
			internal const int idx_OnLostFocus = 26;
			internal const int idx_OnDragEnter = 27;
			internal const int idx_OnDragLeave = 28;
			internal const int idx_OnDragOver = 29;
			internal const int idx_OnDrop = 30;
		}
	}

	// Windows.UI.Xaml.Controls.IControlProtected
	public unsafe static class IControlProtected__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IControlProtected'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object get_DefaultStyleKey(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.UI.Xaml.Controls.IControlProtected>(
									__this, 
									global::Windows.UI.Xaml.Controls.IControlProtected__Impl.Vtbl.idx_get_DefaultStyleKey
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_DefaultStyleKey(
						global::System.__ComObject __this, 
						object value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_object__<global::Windows.UI.Xaml.Controls.IControlProtected>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IControlProtected__Impl.Vtbl.idx_put_DefaultStyleKey
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.DependencyObject GetTemplateChild(
						global::System.__ComObject __this, 
						string childName)
			{
				global::Windows.UI.Xaml.DependencyObject __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.UI.Xaml.Controls.IControlProtected, global::Windows.UI.Xaml.DependencyObject>(
									__this, 
									childName, 
									global::Windows.UI.Xaml.Controls.IControlProtected__Impl.Vtbl.idx_GetTemplateChild
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IControlProtected'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControlProtected))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IControlProtected
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IControlProtected.DefaultStyleKey")]
			object global::Windows.UI.Xaml.Controls.IControlProtected.get_DefaultStyleKey()
			{
				object __retVal = global::Windows.UI.Xaml.Controls.IControlProtected__Impl.StubClass.get_DefaultStyleKey(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IControlProtected.DefaultStyleKey")]
			void global::Windows.UI.Xaml.Controls.IControlProtected.put_DefaultStyleKey(object value)
			{
				global::Windows.UI.Xaml.Controls.IControlProtected__Impl.StubClass.put_DefaultStyleKey(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.DependencyObject global::Windows.UI.Xaml.Controls.IControlProtected.GetTemplateChild(string childName)
			{
				global::Windows.UI.Xaml.DependencyObject __retVal = global::Windows.UI.Xaml.Controls.IControlProtected__Impl.StubClass.GetTemplateChild(
									this, 
									childName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IControlProtected'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControlProtected))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_DefaultStyleKey = 6;
			internal const int idx_put_DefaultStyleKey = 7;
			internal const int idx_GetTemplateChild = 8;
		}
	}

	// Windows.UI.Xaml.Controls.IControl2
	public unsafe static class IControl2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IControl2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IControl3
	public unsafe static class IControl3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IControl3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IControl4
	public unsafe static class IControl4__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IControl4'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.IControl4.add_FocusEngaged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_Control__Windows_UI_Xaml_Controls_FocusEngagedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_FocusEngaged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget72>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusEngagedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IControl4).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IControl4__Impl.Vtbl.idx_add_FocusEngaged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_FocusEngaged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IControl4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IControl4__Impl.Vtbl.idx_remove_FocusEngaged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IControl4.add_FocusDisengaged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_Control__Windows_UI_Xaml_Controls_FocusDisengagedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_FocusDisengaged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget73>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_Control_j_Windows_UI_Xaml_Controls_FocusDisengagedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IControl4).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IControl4__Impl.Vtbl.idx_add_FocusDisengaged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_FocusDisengaged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IControl4>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IControl4__Impl.Vtbl.idx_remove_FocusDisengaged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IControl4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl4))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IControl4
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IControl4.FocusEngaged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IControl4.add_FocusEngaged(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusEngagedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IControl4__Impl.StubClass.add_FocusEngaged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IControl4.FocusEngaged")]
			void global::Windows.UI.Xaml.Controls.IControl4.remove_FocusEngaged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IControl4__Impl.StubClass.remove_FocusEngaged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IControl4.FocusDisengaged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IControl4.add_FocusDisengaged(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.Control, global::Windows.UI.Xaml.Controls.FocusDisengagedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IControl4__Impl.StubClass.add_FocusDisengaged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IControl4.FocusDisengaged")]
			void global::Windows.UI.Xaml.Controls.IControl4.remove_FocusDisengaged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IControl4__Impl.StubClass.remove_FocusDisengaged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IControl4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IControl4))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_FocusEngaged = 22;
			internal const int idx_remove_FocusEngaged = 23;
			internal const int idx_add_FocusDisengaged = 24;
			internal const int idx_remove_FocusDisengaged = 25;
		}
	}

	// Windows.UI.Xaml.Controls.IFocusEngagedEventArgs
	public unsafe static class IFocusEngagedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IFocusEngagedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFocusEngagedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IFocusDisengagedEventArgs
	public unsafe static class IFocusDisengagedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IFocusDisengagedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFocusDisengagedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IUserControlFactory
	public unsafe static class IUserControlFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IUserControlFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IUserControlFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IUserControlFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IUserControlFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IUserControlFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IUserControlFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IUserControlFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IUserControlFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IUserControlFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IUserControlFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IUserControl
	public unsafe static class IUserControl__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IUserControl'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.UIElement get_Content(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.UIElement __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IUserControl, global::Windows.UI.Xaml.UIElement>(
									__this, 
									global::Windows.UI.Xaml.Controls.IUserControl__Impl.Vtbl.idx_get_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Content(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.UIElement value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IUserControl, global::Windows.UI.Xaml.UIElement>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IUserControl__Impl.Vtbl.idx_put_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IUserControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IUserControl))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IUserControl
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IUserControl.Content")]
			global::Windows.UI.Xaml.UIElement global::Windows.UI.Xaml.Controls.IUserControl.get_Content()
			{
				global::Windows.UI.Xaml.UIElement __retVal = global::Windows.UI.Xaml.Controls.IUserControl__Impl.StubClass.get_Content(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IUserControl.Content")]
			void global::Windows.UI.Xaml.Controls.IUserControl.put_Content(global::Windows.UI.Xaml.UIElement value)
			{
				global::Windows.UI.Xaml.Controls.IUserControl__Impl.StubClass.put_Content(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IUserControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IUserControl))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Content = 6;
			internal const int idx_put_Content = 7;
		}
	}

	// Windows.UI.Xaml.Controls.IPageFactory
	public unsafe static class IPageFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IPageFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IPageFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IPageFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IPageFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPageFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IPageFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IPageFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IPageFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IPageFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPageFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IPage
	public unsafe static class IPage__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IPage'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPage))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IPageOverrides
	public unsafe static class IPageOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IPageOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnNavigatedFrom(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IPageOverrides, global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.Vtbl.idx_OnNavigatedFrom
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnNavigatedTo(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IPageOverrides, global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.Vtbl.idx_OnNavigatedTo
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnNavigatingFrom(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IPageOverrides, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs>(
									__this, 
									e, 
									global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.Vtbl.idx_OnNavigatingFrom
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IPageOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPageOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IPageOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IPageOverrides.OnNavigatedFrom(global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.StubClass.OnNavigatedFrom(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IPageOverrides.OnNavigatedTo(global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.StubClass.OnNavigatedTo(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IPageOverrides.OnNavigatingFrom(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e)
			{
				global::Windows.UI.Xaml.Controls.IPageOverrides__Impl.StubClass.OnNavigatingFrom(
									this, 
									e
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IPageOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPageOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnNavigatedFrom = 6;
			internal const int idx_OnNavigatedTo = 7;
			internal const int idx_OnNavigatingFrom = 8;
		}
	}

	// Windows.UI.Xaml.Controls.IGridStatics
	public unsafe static class IGridStatics__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IGridStatics'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetRow(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.FrameworkElement element)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__int__<global::Windows.UI.Xaml.Controls.IGridStatics, global::Windows.UI.Xaml.FrameworkElement>(
									__this, 
									element, 
									global::Windows.UI.Xaml.Controls.IGridStatics__Impl.Vtbl.idx_GetRow
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void SetRow(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.FrameworkElement element, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int__<global::Windows.UI.Xaml.Controls.IGridStatics, global::Windows.UI.Xaml.FrameworkElement>(
									__this, 
									element, 
									value, 
									global::Windows.UI.Xaml.Controls.IGridStatics__Impl.Vtbl.idx_SetRow
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static int GetColumn(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.FrameworkElement element)
			{
				int __ret = global::McgInterop.ForwardComSharedStubs.Func_TArg0__int__<global::Windows.UI.Xaml.Controls.IGridStatics, global::Windows.UI.Xaml.FrameworkElement>(
									__this, 
									element, 
									global::Windows.UI.Xaml.Controls.IGridStatics__Impl.Vtbl.idx_GetColumn
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void SetColumn(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.FrameworkElement element, 
						int value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__int__<global::Windows.UI.Xaml.Controls.IGridStatics, global::Windows.UI.Xaml.FrameworkElement>(
									__this, 
									element, 
									value, 
									global::Windows.UI.Xaml.Controls.IGridStatics__Impl.Vtbl.idx_SetColumn
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IGridStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGridStatics))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IGridStatics
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::Windows.UI.Xaml.Controls.IGridStatics.GetRow(global::Windows.UI.Xaml.FrameworkElement element)
			{
				int __retVal = global::Windows.UI.Xaml.Controls.IGridStatics__Impl.StubClass.GetRow(
									this, 
									element
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IGridStatics.SetRow(
						global::Windows.UI.Xaml.FrameworkElement element, 
						int value)
			{
				global::Windows.UI.Xaml.Controls.IGridStatics__Impl.StubClass.SetRow(
									this, 
									element, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			int global::Windows.UI.Xaml.Controls.IGridStatics.GetColumn(global::Windows.UI.Xaml.FrameworkElement element)
			{
				int __retVal = global::Windows.UI.Xaml.Controls.IGridStatics__Impl.StubClass.GetColumn(
									this, 
									element
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IGridStatics.SetColumn(
						global::Windows.UI.Xaml.FrameworkElement element, 
						int value)
			{
				global::Windows.UI.Xaml.Controls.IGridStatics__Impl.StubClass.SetColumn(
									this, 
									element, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IGridStatics'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGridStatics))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_GetRow = 7;
			internal const int idx_SetRow = 8;
			internal const int idx_GetColumn = 10;
			internal const int idx_SetColumn = 11;
		}
	}

	// Windows.UI.Xaml.Controls.IPanel
	public unsafe static class IPanel__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IPanel'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Controls.UIElementCollection get_Children(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Controls.UIElementCollection __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IPanel, global::Windows.UI.Xaml.Controls.UIElementCollection>(
									__this, 
									global::Windows.UI.Xaml.Controls.IPanel__Impl.Vtbl.idx_get_Children
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Brush get_Background(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Brush __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IPanel, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									global::Windows.UI.Xaml.Controls.IPanel__Impl.Vtbl.idx_get_Background
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Background(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Brush value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IPanel, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IPanel__Impl.Vtbl.idx_put_Background
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IPanel'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPanel))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IPanel
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IPanel.Children")]
			global::Windows.UI.Xaml.Controls.UIElementCollection global::Windows.UI.Xaml.Controls.IPanel.get_Children()
			{
				global::Windows.UI.Xaml.Controls.UIElementCollection __retVal = global::Windows.UI.Xaml.Controls.IPanel__Impl.StubClass.get_Children(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IPanel.Background")]
			global::Windows.UI.Xaml.Media.Brush global::Windows.UI.Xaml.Controls.IPanel.get_Background()
			{
				global::Windows.UI.Xaml.Media.Brush __retVal = global::Windows.UI.Xaml.Controls.IPanel__Impl.StubClass.get_Background(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IPanel.Background")]
			void global::Windows.UI.Xaml.Controls.IPanel.put_Background(global::Windows.UI.Xaml.Media.Brush value)
			{
				global::Windows.UI.Xaml.Controls.IPanel__Impl.StubClass.put_Background(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IPanel'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IPanel))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Children = 6;
			internal const int idx_get_Background = 7;
			internal const int idx_put_Background = 8;
		}
	}

	// Windows.UI.Xaml.Controls.IUIElementCollection
	public unsafe static class IUIElementCollection__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IUIElementCollection'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IUIElementCollection))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IGridFactory
	public unsafe static class IGridFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IGridFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IGridFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IGridFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IGridFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGridFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IGridFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IGridFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IGridFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IGridFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGridFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IGrid
	public unsafe static class IGrid__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IGrid'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Controls.RowDefinitionCollection get_RowDefinitions(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Controls.RowDefinitionCollection __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IGrid, global::Windows.UI.Xaml.Controls.RowDefinitionCollection>(
									__this, 
									global::Windows.UI.Xaml.Controls.IGrid__Impl.Vtbl.idx_get_RowDefinitions
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IGrid'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGrid))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IGrid
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IGrid.RowDefinitions")]
			global::Windows.UI.Xaml.Controls.RowDefinitionCollection global::Windows.UI.Xaml.Controls.IGrid.get_RowDefinitions()
			{
				global::Windows.UI.Xaml.Controls.RowDefinitionCollection __retVal = global::Windows.UI.Xaml.Controls.IGrid__Impl.StubClass.get_RowDefinitions(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IGrid'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGrid))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_RowDefinitions = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IRowDefinition
	public unsafe static class IRowDefinition__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IRowDefinition'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.GridLength get_Height(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.GridLength __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_GridLength__<global::Windows.UI.Xaml.Controls.IRowDefinition>(
									__this, 
									global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl.idx_get_Height
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Controls.IRowDefinition.put_Height, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_UI_Xaml_GridLength__Windows_UI_Xaml__GridLength, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Height(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.GridLength value)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Controls.IRowDefinition).TypeHandle, 
									global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.Vtbl.idx_put_Height, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IRowDefinition'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRowDefinition))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IRowDefinition
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IRowDefinition.Height")]
			global::Windows.UI.Xaml.GridLength global::Windows.UI.Xaml.Controls.IRowDefinition.get_Height()
			{
				global::Windows.UI.Xaml.GridLength __retVal = global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.StubClass.get_Height(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IRowDefinition.Height")]
			void global::Windows.UI.Xaml.Controls.IRowDefinition.put_Height(global::Windows.UI.Xaml.GridLength value)
			{
				global::Windows.UI.Xaml.Controls.IRowDefinition__Impl.StubClass.put_Height(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IRowDefinition'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRowDefinition))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Height = 6;
			internal const int idx_put_Height = 7;
		}
	}

	// Windows.UI.Xaml.Controls.IGrid2
	public unsafe static class IGrid2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IGrid2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IGrid2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IBorder
	public unsafe static class IBorder__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IBorder'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Brush get_BorderBrush(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Brush __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.IBorder, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									global::Windows.UI.Xaml.Controls.IBorder__Impl.Vtbl.idx_get_BorderBrush
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_BorderBrush(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Brush value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.IBorder, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IBorder__Impl.Vtbl.idx_put_BorderBrush
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Thickness get_BorderThickness(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Thickness __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IBorder>(
									__this, 
									global::Windows.UI.Xaml.Controls.IBorder__Impl.Vtbl.idx_get_BorderThickness
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_BorderThickness(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Thickness value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_UI_Xaml_Thickness__<global::Windows.UI.Xaml.Controls.IBorder>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IBorder__Impl.Vtbl.idx_put_BorderThickness
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IBorder'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IBorder))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IBorder
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IBorder.BorderBrush")]
			global::Windows.UI.Xaml.Media.Brush global::Windows.UI.Xaml.Controls.IBorder.get_BorderBrush()
			{
				global::Windows.UI.Xaml.Media.Brush __retVal = global::Windows.UI.Xaml.Controls.IBorder__Impl.StubClass.get_BorderBrush(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IBorder.BorderBrush")]
			void global::Windows.UI.Xaml.Controls.IBorder.put_BorderBrush(global::Windows.UI.Xaml.Media.Brush value)
			{
				global::Windows.UI.Xaml.Controls.IBorder__Impl.StubClass.put_BorderBrush(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IBorder.BorderThickness")]
			global::Windows.UI.Xaml.Thickness global::Windows.UI.Xaml.Controls.IBorder.get_BorderThickness()
			{
				global::Windows.UI.Xaml.Thickness __retVal = global::Windows.UI.Xaml.Controls.IBorder__Impl.StubClass.get_BorderThickness(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IBorder.BorderThickness")]
			void global::Windows.UI.Xaml.Controls.IBorder.put_BorderThickness(global::Windows.UI.Xaml.Thickness value)
			{
				global::Windows.UI.Xaml.Controls.IBorder__Impl.StubClass.put_BorderThickness(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IBorder'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IBorder))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_BorderBrush = 6;
			internal const int idx_put_BorderBrush = 7;
			internal const int idx_get_BorderThickness = 8;
			internal const int idx_put_BorderThickness = 9;
		}
	}

	// Windows.UI.Xaml.Controls.IContentControl
	public unsafe static class IContentControl__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IContentControl'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object get_Content(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.UI.Xaml.Controls.IContentControl>(
									__this, 
									global::Windows.UI.Xaml.Controls.IContentControl__Impl.Vtbl.idx_get_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Content(
						global::System.__ComObject __this, 
						object value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_object__<global::Windows.UI.Xaml.Controls.IContentControl>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IContentControl__Impl.Vtbl.idx_put_Content
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IContentControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContentControl))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IContentControl
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IContentControl.Content")]
			object global::Windows.UI.Xaml.Controls.IContentControl.get_Content()
			{
				object __retVal = global::Windows.UI.Xaml.Controls.IContentControl__Impl.StubClass.get_Content(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IContentControl.Content")]
			void global::Windows.UI.Xaml.Controls.IContentControl.put_Content(object value)
			{
				global::Windows.UI.Xaml.Controls.IContentControl__Impl.StubClass.put_Content(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IContentControl'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContentControl))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Content = 6;
			internal const int idx_put_Content = 7;
		}
	}

	// Windows.UI.Xaml.Controls.IContentControlOverrides
	public unsafe static class IContentControlOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IContentControlOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnContentChanged(
						global::System.__ComObject __this, 
						object oldContent, 
						object newContent)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_object__object__<global::Windows.UI.Xaml.Controls.IContentControlOverrides>(
									__this, 
									oldContent, 
									newContent, 
									global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.Vtbl.idx_OnContentChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnContentTemplateChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.DataTemplate oldContentTemplate, 
						global::Windows.UI.Xaml.DataTemplate newContentTemplate)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.IContentControlOverrides, global::Windows.UI.Xaml.DataTemplate, global::Windows.UI.Xaml.DataTemplate>(
									__this, 
									oldContentTemplate, 
									newContentTemplate, 
									global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.Vtbl.idx_OnContentTemplateChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnContentTemplateSelectorChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.DataTemplateSelector oldContentTemplateSelector, 
						global::Windows.UI.Xaml.Controls.DataTemplateSelector newContentTemplateSelector)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__TArg1__<global::Windows.UI.Xaml.Controls.IContentControlOverrides, global::Windows.UI.Xaml.Controls.DataTemplateSelector, global::Windows.UI.Xaml.Controls.DataTemplateSelector>(
									__this, 
									oldContentTemplateSelector, 
									newContentTemplateSelector, 
									global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.Vtbl.idx_OnContentTemplateSelectorChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IContentControlOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContentControlOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IContentControlOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IContentControlOverrides.OnContentChanged(
						object oldContent, 
						object newContent)
			{
				global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.StubClass.OnContentChanged(
									this, 
									oldContent, 
									newContent
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IContentControlOverrides.OnContentTemplateChanged(
						global::Windows.UI.Xaml.DataTemplate oldContentTemplate, 
						global::Windows.UI.Xaml.DataTemplate newContentTemplate)
			{
				global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.StubClass.OnContentTemplateChanged(
									this, 
									oldContentTemplate, 
									newContentTemplate
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.IContentControlOverrides.OnContentTemplateSelectorChanged(
						global::Windows.UI.Xaml.Controls.DataTemplateSelector oldContentTemplateSelector, 
						global::Windows.UI.Xaml.Controls.DataTemplateSelector newContentTemplateSelector)
			{
				global::Windows.UI.Xaml.Controls.IContentControlOverrides__Impl.StubClass.OnContentTemplateSelectorChanged(
									this, 
									oldContentTemplateSelector, 
									newContentTemplateSelector
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IContentControlOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContentControlOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnContentChanged = 6;
			internal const int idx_OnContentTemplateChanged = 7;
			internal const int idx_OnContentTemplateSelectorChanged = 8;
		}
	}

	// Windows.UI.Xaml.Controls.IDataTemplateSelector
	public unsafe static class IDataTemplateSelector__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IDataTemplateSelector'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelector))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides
	public unsafe static class IDataTemplateSelectorOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides.SelectTemplateCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [in] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_DependencyObject__Windows_UI_Xaml__DependencyObject *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_DataTemplate__Windows_UI_Xaml__DataTemplate *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.DataTemplate SelectTemplateCore(
						global::System.__ComObject __this, 
						object item, 
						global::Windows.UI.Xaml.DependencyObject container)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_item = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl** unsafe_container = default(global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl**);
				global::Windows.UI.Xaml.IDataTemplate__Impl.Vtbl** unsafe_returnValue__retval = default(global::Windows.UI.Xaml.IDataTemplate__Impl.Vtbl**);
				global::Windows.UI.Xaml.DataTemplate returnValue__retval = default(global::Windows.UI.Xaml.DataTemplate);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_item = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(item);
					unsafe_container = (global::Windows.UI.Xaml.IDependencyObject__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
										container, 
										typeof(global::Windows.UI.Xaml.DependencyObject).TypeHandle
									);
					unsafe_returnValue__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides__Impl.Vtbl.idx_SelectTemplateCore, 
										unsafe_item, 
										unsafe_container, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = (global::Windows.UI.Xaml.DataTemplate)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_returnValue__retval), 
										typeof(global::Windows.UI.Xaml.DataTemplate).TypeHandle
									);
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_item)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_container)));
					global::System.GC.KeepAlive(container);
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_returnValue__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.DataTemplate global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides.SelectTemplateCore(
						object item, 
						global::Windows.UI.Xaml.DependencyObject container)
			{
				global::Windows.UI.Xaml.DataTemplate __retVal = global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides__Impl.StubClass.SelectTemplateCore(
									this, 
									item, 
									container
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_SelectTemplateCore = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IDataTemplateSelector2
	public unsafe static class IDataTemplateSelector2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IDataTemplateSelector2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelector2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2
	public unsafe static class IDataTemplateSelectorOverrides2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2.SelectTemplateCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTClassMarshaller] Windows_UI_Xaml_DataTemplate__Windows_UI_Xaml__DataTemplate *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.DataTemplate SelectTemplateCore(
						global::System.__ComObject __this, 
						object item)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_item = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::Windows.UI.Xaml.IDataTemplate__Impl.Vtbl** unsafe_returnValue__retval = default(global::Windows.UI.Xaml.IDataTemplate__Impl.Vtbl**);
				global::Windows.UI.Xaml.DataTemplate returnValue__retval = default(global::Windows.UI.Xaml.DataTemplate);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_item = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(item);
					unsafe_returnValue__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2__Impl.Vtbl.idx_SelectTemplateForItemCore, 
										unsafe_item, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = (global::Windows.UI.Xaml.DataTemplate)global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject(
										((global::System.IntPtr)unsafe_returnValue__retval), 
										typeof(global::Windows.UI.Xaml.DataTemplate).TypeHandle
									);
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_item)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_returnValue__retval)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.DataTemplate global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2.SelectTemplateCore(object item)
			{
				global::Windows.UI.Xaml.DataTemplate __retVal = global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2__Impl.StubClass.SelectTemplateCore(
									this, 
									item
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_SelectTemplateForItemCore = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IContentControl2
	public unsafe static class IContentControl2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IContentControl2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContentControl2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IButtonFactory
	public unsafe static class IButtonFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IButtonFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IButtonFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IButtonFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IButtonFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IButtonFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IButtonFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IButtonFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IButtonFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IButtonFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IButtonFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IButton
	public unsafe static class IButton__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IButton'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IButton))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IButtonWithFlyout
	public unsafe static class IButtonWithFlyout__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IButtonWithFlyout'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IButtonWithFlyout))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBlock
	public unsafe static class ITextBlock__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITextBlock'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_FontSize(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_FontSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FontSize(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_FontSize
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.FontFamily get_FontFamily(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.FontFamily __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.ITextBlock, global::Windows.UI.Xaml.Media.FontFamily>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_FontFamily
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FontFamily(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.FontFamily value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.ITextBlock, global::Windows.UI.Xaml.Media.FontFamily>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_FontFamily
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBlock.get_FontWeight, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableStructMarshaller] Windows_UI_Text_FontWeight__Windows_UI_Text__FontWeight, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Text.FontWeight get_FontWeight(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Text.FontWeight unsafe_value__retval;
				global::Windows.UI.Text.FontWeight value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Controls.ITextBlock).TypeHandle, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_FontWeight, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBlock.put_FontWeight, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableStructMarshaller] Windows_UI_Text_FontWeight__Windows_UI_Text__FontWeight, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_FontWeight(
						global::System.__ComObject __this, 
						global::Windows.UI.Text.FontWeight value)
			{
				// Setup
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Controls.ITextBlock).TypeHandle, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_FontWeight, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				// Return
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Brush get_Foreground(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.Brush __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.ITextBlock, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_Foreground
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Foreground(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Brush value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Controls.ITextBlock, global::Windows.UI.Xaml.Media.Brush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_Foreground
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.TextWrapping get_TextWrapping(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.TextWrapping __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_TextWrapping__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_TextWrapping
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_TextWrapping(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.TextWrapping value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_TextWrapping
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Text(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Text(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_put_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Documents.InlineCollection get_Inlines(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Documents.InlineCollection __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Controls.ITextBlock, global::Windows.UI.Xaml.Documents.InlineCollection>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_get_Inlines
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_SelectionChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_add_SelectionChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_SelectionChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_remove_SelectionChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ContextMenuOpening(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Controls_ContextMenuOpeningEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_add_ContextMenuOpening
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ContextMenuOpening(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBlock>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBlock__Impl.Vtbl.idx_remove_ContextMenuOpening
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITextBlock'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBlock))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITextBlock
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.FontSize")]
			double global::Windows.UI.Xaml.Controls.ITextBlock.get_FontSize()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_FontSize(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.FontSize")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_FontSize(double value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_FontSize(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.FontFamily")]
			global::Windows.UI.Xaml.Media.FontFamily global::Windows.UI.Xaml.Controls.ITextBlock.get_FontFamily()
			{
				global::Windows.UI.Xaml.Media.FontFamily __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_FontFamily(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.FontFamily")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_FontFamily(global::Windows.UI.Xaml.Media.FontFamily value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_FontFamily(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.FontWeight")]
			global::Windows.UI.Text.FontWeight global::Windows.UI.Xaml.Controls.ITextBlock.get_FontWeight()
			{
				global::Windows.UI.Text.FontWeight __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_FontWeight(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.FontWeight")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_FontWeight(global::Windows.UI.Text.FontWeight value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_FontWeight(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.Foreground")]
			global::Windows.UI.Xaml.Media.Brush global::Windows.UI.Xaml.Controls.ITextBlock.get_Foreground()
			{
				global::Windows.UI.Xaml.Media.Brush __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_Foreground(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.Foreground")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_Foreground(global::Windows.UI.Xaml.Media.Brush value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_Foreground(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.TextWrapping")]
			global::Windows.UI.Xaml.TextWrapping global::Windows.UI.Xaml.Controls.ITextBlock.get_TextWrapping()
			{
				global::Windows.UI.Xaml.TextWrapping __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_TextWrapping(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.TextWrapping")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_TextWrapping(global::Windows.UI.Xaml.TextWrapping value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_TextWrapping(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.Text")]
			string global::Windows.UI.Xaml.Controls.ITextBlock.get_Text()
			{
				string __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_Text(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBlock.Text")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.put_Text(string value)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.put_Text(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBlock.Inlines")]
			global::Windows.UI.Xaml.Documents.InlineCollection global::Windows.UI.Xaml.Controls.ITextBlock.get_Inlines()
			{
				global::Windows.UI.Xaml.Documents.InlineCollection __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.get_Inlines(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBlock.SelectionChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBlock.add_SelectionChanged(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.add_SelectionChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBlock.SelectionChanged")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.remove_SelectionChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.remove_SelectionChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBlock.ContextMenuOpening")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBlock.add_ContextMenuOpening(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.add_ContextMenuOpening(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBlock.ContextMenuOpening")]
			void global::Windows.UI.Xaml.Controls.ITextBlock.remove_ContextMenuOpening(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBlock__Impl.StubClass.remove_ContextMenuOpening(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITextBlock'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBlock))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_FontSize = 6;
			internal const int idx_put_FontSize = 7;
			internal const int idx_get_FontFamily = 8;
			internal const int idx_put_FontFamily = 9;
			internal const int idx_get_FontWeight = 10;
			internal const int idx_put_FontWeight = 11;
			internal const int idx_get_Foreground = 18;
			internal const int idx_put_Foreground = 19;
			internal const int idx_get_TextWrapping = 20;
			internal const int idx_put_TextWrapping = 21;
			internal const int idx_get_Text = 26;
			internal const int idx_put_Text = 27;
			internal const int idx_get_Inlines = 28;
			internal const int idx_add_SelectionChanged = 43;
			internal const int idx_remove_SelectionChanged = 44;
			internal const int idx_add_ContextMenuOpening = 45;
			internal const int idx_remove_ContextMenuOpening = 46;
		}
	}

	// Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler
	public unsafe static class ContextMenuOpeningEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.ContextMenuEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler, global::Windows.UI.Xaml.Controls.ContextMenuEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Controls__ContextMenuOpeningEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Controls__ContextMenuOpeningEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl.Windows_UI_Xaml_Controls_ContextMenuOpeningEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Controls_ContextMenuOpeningEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Controls__ContextMenuOpeningEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget77>(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.IContextMenuEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.ContextMenuEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Controls_ContextMenuOpeningEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Controls_ContextMenuOpeningEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Controls.IContextMenuEventArgs
	public unsafe static class IContextMenuEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IContextMenuEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IContextMenuEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBlock2
	public unsafe static class ITextBlock2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextBlock2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBlock2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBlock3
	public unsafe static class ITextBlock3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextBlock3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBlock3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBlock4
	public unsafe static class ITextBlock4__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextBlock4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBlock4))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ISliderFactory
	public unsafe static class ISliderFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ISliderFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.ISliderFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.ISliderFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ISliderFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ISliderFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ISliderFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.ISliderFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.ISliderFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ISliderFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ISliderFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.ISlider
	public unsafe static class ISlider__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ISlider'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_StepFrequency(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.ISlider>(
									__this, 
									global::Windows.UI.Xaml.Controls.ISlider__Impl.Vtbl.idx_get_StepFrequency
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_StepFrequency(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.ISlider>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ISlider__Impl.Vtbl.idx_put_StepFrequency
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ISlider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ISlider))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ISlider
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ISlider.StepFrequency")]
			double global::Windows.UI.Xaml.Controls.ISlider.get_StepFrequency()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.ISlider__Impl.StubClass.get_StepFrequency(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ISlider.StepFrequency")]
			void global::Windows.UI.Xaml.Controls.ISlider.put_StepFrequency(double value)
			{
				global::Windows.UI.Xaml.Controls.ISlider__Impl.StubClass.put_StepFrequency(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ISlider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ISlider))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_StepFrequency = 8;
			internal const int idx_put_StepFrequency = 9;
		}
	}

	// Windows.UI.Xaml.Controls.ISlider2
	public unsafe static class ISlider2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ISlider2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ISlider2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBoxFactory
	public unsafe static class ITextBoxFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITextBoxFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.ITextBoxFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.ITextBoxFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITextBoxFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBoxFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITextBoxFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.ITextBoxFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.ITextBoxFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITextBoxFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBoxFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.ITextBox
	public unsafe static class ITextBox__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITextBox'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Text(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_get_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Text(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_put_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.TextWrapping get_TextWrapping(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.TextWrapping __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_TextWrapping__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_get_TextWrapping
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_TextWrapping(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.TextWrapping value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_put_TextWrapping
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBox.add_TextChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Controls_TextChangedEventHandler__Windows_UI_Xaml_Controls__TextChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TextChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.TextChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Controls.TextChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget80>(global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_add_TextChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TextChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_remove_TextChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_SelectionChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_add_SelectionChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_SelectionChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_remove_SelectionChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ContextMenuOpening(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_Controls_ContextMenuOpeningEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_add_ContextMenuOpening
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ContextMenuOpening(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox__Impl.Vtbl.idx_remove_ContextMenuOpening
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITextBox'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITextBox
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBox.Text")]
			string global::Windows.UI.Xaml.Controls.ITextBox.get_Text()
			{
				string __retVal = global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.get_Text(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBox.Text")]
			void global::Windows.UI.Xaml.Controls.ITextBox.put_Text(string value)
			{
				global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.put_Text(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITextBox.TextWrapping")]
			global::Windows.UI.Xaml.TextWrapping global::Windows.UI.Xaml.Controls.ITextBox.get_TextWrapping()
			{
				global::Windows.UI.Xaml.TextWrapping __retVal = global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.get_TextWrapping(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITextBox.TextWrapping")]
			void global::Windows.UI.Xaml.Controls.ITextBox.put_TextWrapping(global::Windows.UI.Xaml.TextWrapping value)
			{
				global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.put_TextWrapping(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox.TextChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox.add_TextChanged(global::Windows.UI.Xaml.Controls.TextChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.add_TextChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox.TextChanged")]
			void global::Windows.UI.Xaml.Controls.ITextBox.remove_TextChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.remove_TextChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox.SelectionChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox.add_SelectionChanged(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.add_SelectionChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox.SelectionChanged")]
			void global::Windows.UI.Xaml.Controls.ITextBox.remove_SelectionChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.remove_SelectionChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox.ContextMenuOpening")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox.add_ContextMenuOpening(global::Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.add_ContextMenuOpening(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox.ContextMenuOpening")]
			void global::Windows.UI.Xaml.Controls.ITextBox.remove_ContextMenuOpening(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox__Impl.StubClass.remove_ContextMenuOpening(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITextBox'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Text = 6;
			internal const int idx_put_Text = 7;
			internal const int idx_get_TextWrapping = 22;
			internal const int idx_put_TextWrapping = 23;
			internal const int idx_add_TextChanged = 30;
			internal const int idx_remove_TextChanged = 31;
			internal const int idx_add_SelectionChanged = 32;
			internal const int idx_remove_SelectionChanged = 33;
			internal const int idx_add_ContextMenuOpening = 34;
			internal const int idx_remove_ContextMenuOpening = 35;
		}
	}

	// Windows.UI.Xaml.Controls.TextChangedEventHandler
	public unsafe static class TextChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.TextChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.TextChangedEventHandler, global::Windows.UI.Xaml.Controls.TextChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Controls.TextChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Controls.TextChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Controls__TextChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Controls__TextChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Controls_TextChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Controls_TextChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Controls__TextChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget81>(global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Controls.TextChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.TextChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Controls_TextChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Controls.TextChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Controls_TextChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Controls.ITextChangedEventArgs
	public unsafe static class ITextChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBox2
	public unsafe static class ITextBox2__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITextBox2'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.ITextBox2.add_Paste, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Controls_TextControlPasteEventHandler__Windows_UI_Xaml_Controls__TextControlPasteEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Paste(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget82>(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox2).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox2__Impl.Vtbl.idx_add_Paste, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Paste(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox2>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox2__Impl.Vtbl.idx_remove_Paste
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITextBox2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox2))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITextBox2
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox2.Paste")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox2.add_Paste(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox2__Impl.StubClass.add_Paste(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox2.Paste")]
			void global::Windows.UI.Xaml.Controls.ITextBox2.remove_Paste(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox2__Impl.StubClass.remove_Paste(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITextBox2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox2))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_Paste = 18;
			internal const int idx_remove_Paste = 19;
		}
	}

	// Windows.UI.Xaml.Controls.TextControlPasteEventHandler
	public unsafe static class TextControlPasteEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler, global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Controls.TextControlPasteEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Controls__TextControlPasteEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Controls__TextControlPasteEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl.Windows_UI_Xaml_Controls_TextControlPasteEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Controls_TextControlPasteEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Controls__TextControlPasteEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget83>(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.ITextControlPasteEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.TextControlPasteEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Controls_TextControlPasteEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Controls.TextControlPasteEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Controls_TextControlPasteEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Controls.ITextControlPasteEventArgs
	public unsafe static class ITextControlPasteEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextControlPasteEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextControlPasteEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBox3
	public unsafe static class ITextBox3__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITextBox3'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionStarted, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox__Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TextCompositionStarted(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget84>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionStartedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox3).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_add_TextCompositionStarted, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TextCompositionStarted(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_remove_TextCompositionStarted
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox__Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TextCompositionChanged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget85>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox3).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_add_TextCompositionChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TextCompositionChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_remove_TextCompositionChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionEnded, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox__Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TextCompositionEnded(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget86>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextCompositionEndedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox3).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_add_TextCompositionEnded, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TextCompositionEnded(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_remove_TextCompositionEnded
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBox3.add_CandidateWindowBoundsChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox__Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_CandidateWindowBoundsChanged(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget87>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_CandidateWindowBoundsChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox3).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_add_CandidateWindowBoundsChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_CandidateWindowBoundsChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_remove_CandidateWindowBoundsChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITextBox3.add_TextChanging, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_Foundation_TypedEventHandler_2_Windows_UI_Xaml_Controls_TextBox__Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs___Windows_Foundation__TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TextChanging(
						global::System.__ComObject __this, 
						global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs> value)
			{
				// Setup
				global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl** unsafe_value = default(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget88>(global::Windows.Foundation.TypedEventHandler_A_Windows_UI_Xaml_Controls_TextBox_j_Windows_UI_Xaml_Controls_TextBoxTextChangingEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITextBox3).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_add_TextChanging, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TextChanging(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITextBox3>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITextBox3__Impl.Vtbl.idx_remove_TextChanging
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITextBox3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox3))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITextBox3
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionStarted")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionStarted(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.add_TextCompositionStarted(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionStarted")]
			void global::Windows.UI.Xaml.Controls.ITextBox3.remove_TextCompositionStarted(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.remove_TextCompositionStarted(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionChanged(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.add_TextCompositionChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionChanged")]
			void global::Windows.UI.Xaml.Controls.ITextBox3.remove_TextCompositionChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.remove_TextCompositionChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionEnded")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox3.add_TextCompositionEnded(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.add_TextCompositionEnded(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox3.TextCompositionEnded")]
			void global::Windows.UI.Xaml.Controls.ITextBox3.remove_TextCompositionEnded(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.remove_TextCompositionEnded(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox3.CandidateWindowBoundsChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox3.add_CandidateWindowBoundsChanged(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.add_CandidateWindowBoundsChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox3.CandidateWindowBoundsChanged")]
			void global::Windows.UI.Xaml.Controls.ITextBox3.remove_CandidateWindowBoundsChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.remove_CandidateWindowBoundsChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITextBox3.TextChanging")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITextBox3.add_TextChanging(global::Windows.Foundation.TypedEventHandler<global::Windows.UI.Xaml.Controls.TextBox, global::Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.add_TextChanging(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITextBox3.TextChanging")]
			void global::Windows.UI.Xaml.Controls.ITextBox3.remove_TextChanging(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITextBox3__Impl.StubClass.remove_TextChanging(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITextBox3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox3))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_TextCompositionStarted = 6;
			internal const int idx_remove_TextCompositionStarted = 7;
			internal const int idx_add_TextCompositionChanged = 8;
			internal const int idx_remove_TextCompositionChanged = 9;
			internal const int idx_add_TextCompositionEnded = 10;
			internal const int idx_remove_TextCompositionEnded = 11;
			internal const int idx_add_CandidateWindowBoundsChanged = 16;
			internal const int idx_remove_CandidateWindowBoundsChanged = 17;
			internal const int idx_add_TextChanging = 18;
			internal const int idx_remove_TextChanging = 19;
		}
	}

	// Windows.UI.Xaml.Controls.ITextCompositionStartedEventArgs
	public unsafe static class ITextCompositionStartedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextCompositionStartedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextCompositionStartedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextCompositionChangedEventArgs
	public unsafe static class ITextCompositionChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextCompositionChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextCompositionChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextCompositionEndedEventArgs
	public unsafe static class ITextCompositionEndedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextCompositionEndedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextCompositionEndedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs
	public unsafe static class ICandidateWindowBoundsChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs
	public unsafe static class ITextBoxTextChangingEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITextBox4
	public unsafe static class ITextBox4__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITextBox4'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITextBox4))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IRadioButtonFactory
	public unsafe static class IRadioButtonFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IRadioButtonFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IRadioButtonFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IRadioButtonFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IRadioButtonFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRadioButtonFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IRadioButtonFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IRadioButtonFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IRadioButtonFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IRadioButtonFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRadioButtonFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IRadioButton
	public unsafe static class IRadioButton__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IRadioButton'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_GroupName(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Controls.IRadioButton>(
									__this, 
									global::Windows.UI.Xaml.Controls.IRadioButton__Impl.Vtbl.idx_get_GroupName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_GroupName(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.UI.Xaml.Controls.IRadioButton>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.IRadioButton__Impl.Vtbl.idx_put_GroupName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IRadioButton'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRadioButton))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IRadioButton
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IRadioButton.GroupName")]
			string global::Windows.UI.Xaml.Controls.IRadioButton.get_GroupName()
			{
				string __retVal = global::Windows.UI.Xaml.Controls.IRadioButton__Impl.StubClass.get_GroupName(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.IRadioButton.GroupName")]
			void global::Windows.UI.Xaml.Controls.IRadioButton.put_GroupName(string value)
			{
				global::Windows.UI.Xaml.Controls.IRadioButton__Impl.StubClass.put_GroupName(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IRadioButton'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IRadioButton))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_GroupName = 6;
			internal const int idx_put_GroupName = 7;
		}
	}

	// Windows.UI.Xaml.Controls.ICheckBoxFactory
	public unsafe static class ICheckBoxFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ICheckBoxFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.ICheckBoxFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.ICheckBoxFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ICheckBoxFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ICheckBoxFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ICheckBoxFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.ICheckBoxFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.ICheckBoxFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ICheckBoxFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ICheckBoxFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.ICheckBox
	public unsafe static class ICheckBox__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ICheckBox'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ICheckBox))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IDatePickerFactory
	public unsafe static class IDatePickerFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IDatePickerFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IDatePickerFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IDatePickerFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IDatePickerFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePickerFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IDatePickerFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IDatePickerFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IDatePickerFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IDatePickerFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePickerFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IDatePicker
	public unsafe static class IDatePicker__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IDatePicker'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.DateTimeOffset get_Date(global::System.__ComObject __this)
			{
				global::System.DateTimeOffset __ret = global::McgInterop.ForwardComSharedStubs.Func_DateTimeOffset__<global::Windows.UI.Xaml.Controls.IDatePicker>(
									__this, 
									global::Windows.UI.Xaml.Controls.IDatePicker__Impl.Vtbl.idx_get_Date
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Controls.IDatePicker.add_DateChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] System_EventHandler_1_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs___Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_DateChanged(
						global::System.__ComObject __this, 
						global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs> value)
			{
				// Setup
				global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget94>(global::System.EventHandler_A_Windows_UI_Xaml_Controls_DatePickerValueChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IDatePicker).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IDatePicker__Impl.Vtbl.idx_add_DateChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_DateChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IDatePicker>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IDatePicker__Impl.Vtbl.idx_remove_DateChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IDatePicker'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePicker))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IDatePicker
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.IDatePicker.Date")]
			global::System.DateTimeOffset global::Windows.UI.Xaml.Controls.IDatePicker.get_Date()
			{
				global::System.DateTimeOffset __retVal = global::Windows.UI.Xaml.Controls.IDatePicker__Impl.StubClass.get_Date(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IDatePicker.DateChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IDatePicker.add_DateChanged(global::System.EventHandler<global::Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IDatePicker__Impl.StubClass.add_DateChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IDatePicker.DateChanged")]
			void global::Windows.UI.Xaml.Controls.IDatePicker.remove_DateChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IDatePicker__Impl.StubClass.remove_DateChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IDatePicker'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePicker))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Date = 12;
			internal const int idx_add_DateChanged = 32;
			internal const int idx_remove_DateChanged = 33;
		}
	}

	// Windows.UI.Xaml.Controls.IDatePickerValueChangedEventArgs
	public unsafe static class IDatePickerValueChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IDatePickerValueChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePickerValueChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IDatePicker2
	public unsafe static class IDatePicker2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IDatePicker2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IDatePicker2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITimePickerFactory
	public unsafe static class ITimePickerFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITimePickerFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.ITimePickerFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.ITimePickerFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITimePickerFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePickerFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITimePickerFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.ITimePickerFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.ITimePickerFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITimePickerFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePickerFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.ITimePicker
	public unsafe static class ITimePicker__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.ITimePicker'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_ClockIdentifier(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Controls.ITimePicker>(
									__this, 
									global::Windows.UI.Xaml.Controls.ITimePicker__Impl.Vtbl.idx_get_ClockIdentifier
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_ClockIdentifier(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.UI.Xaml.Controls.ITimePicker>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.ITimePicker__Impl.Vtbl.idx_put_ClockIdentifier
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.ITimePicker.get_Time, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_TimeSpan__Windows_Foundation__TimeSpan, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.TimeSpan get_Time(global::System.__ComObject __this)
			{
				// Setup
				global::System.TimeSpan unsafe_value__retval;
				global::System.TimeSpan value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Controls.ITimePicker).TypeHandle, 
									global::Windows.UI.Xaml.Controls.ITimePicker__Impl.Vtbl.idx_get_Time, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			// Signature, Windows.UI.Xaml.Controls.ITimePicker.add_TimeChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] System_EventHandler_1_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs___Windows_Foundation__EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V_ *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_TimeChanged(
						global::System.__ComObject __this, 
						global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs> value)
			{
				// Setup
				global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl** unsafe_value = default(global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs>).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget96>(global::System.EventHandler_A_Windows_UI_Xaml_Controls_TimePickerValueChangedEventArgs_V___Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.ITimePicker).TypeHandle, 
										global::Windows.UI.Xaml.Controls.ITimePicker__Impl.Vtbl.idx_add_TimeChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_TimeChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.ITimePicker>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.ITimePicker__Impl.Vtbl.idx_remove_TimeChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.ITimePicker'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePicker))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.ITimePicker
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITimePicker.ClockIdentifier")]
			string global::Windows.UI.Xaml.Controls.ITimePicker.get_ClockIdentifier()
			{
				string __retVal = global::Windows.UI.Xaml.Controls.ITimePicker__Impl.StubClass.get_ClockIdentifier(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.ITimePicker.ClockIdentifier")]
			void global::Windows.UI.Xaml.Controls.ITimePicker.put_ClockIdentifier(string value)
			{
				global::Windows.UI.Xaml.Controls.ITimePicker__Impl.StubClass.put_ClockIdentifier(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.ITimePicker.Time")]
			global::System.TimeSpan global::Windows.UI.Xaml.Controls.ITimePicker.get_Time()
			{
				global::System.TimeSpan __retVal = global::Windows.UI.Xaml.Controls.ITimePicker__Impl.StubClass.get_Time(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.ITimePicker.TimeChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.ITimePicker.add_TimeChanged(global::System.EventHandler<global::Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs> value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.ITimePicker__Impl.StubClass.add_TimeChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.ITimePicker.TimeChanged")]
			void global::Windows.UI.Xaml.Controls.ITimePicker.remove_TimeChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.ITimePicker__Impl.StubClass.remove_TimeChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.ITimePicker'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePicker))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_ClockIdentifier = 10;
			internal const int idx_put_ClockIdentifier = 11;
			internal const int idx_get_Time = 14;
			internal const int idx_add_TimeChanged = 16;
			internal const int idx_remove_TimeChanged = 17;
		}
	}

	// Windows.UI.Xaml.Controls.ITimePickerValueChangedEventArgs
	public unsafe static class ITimePickerValueChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITimePickerValueChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePickerValueChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.ITimePicker2
	public unsafe static class ITimePicker2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.ITimePicker2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.ITimePicker2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IFrameFactory
	public unsafe static class IFrameFactory__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IFrameFactory'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.IntPtr CreateInstance(
						global::System.__ComObject __this, 
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __ret = global::McgInterop.ForwardComSharedStubs.Func_IntPtr__out_IntPtr__IntPtr__<global::Windows.UI.Xaml.Controls.IFrameFactory>(
									__this, 
									outer, 
									out inner, 
									global::Windows.UI.Xaml.Controls.IFrameFactory__Impl.Vtbl.idx_CreateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IFrameFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrameFactory))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IFrameFactory
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::System.IntPtr global::Windows.UI.Xaml.Controls.IFrameFactory.CreateInstance(
						global::System.IntPtr outer, 
						out global::System.IntPtr inner)
			{
				global::System.IntPtr __retVal = global::Windows.UI.Xaml.Controls.IFrameFactory__Impl.StubClass.CreateInstance(
									this, 
									outer, 
									out inner
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IFrameFactory'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrameFactory))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_CreateInstance = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IFrame
	public unsafe static class IFrame__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.IFrame'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.IFrame.add_Navigated, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Navigation_NavigatedEventHandler__Windows_UI_Xaml_Navigation__NavigatedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Navigated(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigatedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget125>(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IFrame).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_add_Navigated, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Navigated(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IFrame>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_remove_Navigated
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IFrame.add_Navigating, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Navigation_NavigatingCancelEventHandler__Windows_UI_Xaml_Navigation__NavigatingCancelEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Navigating(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget126>(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IFrame).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_add_Navigating, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Navigating(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IFrame>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_remove_Navigating
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IFrame.add_NavigationFailed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Navigation_NavigationFailedEventHandler__Windows_UI_Xaml_Navigation__NavigationFailedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_NavigationFailed(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget127>(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IFrame).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_add_NavigationFailed, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_NavigationFailed(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IFrame>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_remove_NavigationFailed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IFrame.add_NavigationStopped, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Navigation_NavigationStoppedEventHandler__Windows_UI_Xaml_Navigation__NavigationStoppedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_NavigationStopped(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget125>(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IFrame).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_add_NavigationStopped, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_NavigationStopped(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.IFrame>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_remove_NavigationStopped
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.IFrame.Navigate, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTTypeNameMarshaller] System_Type__Windows_UI_Xaml_Interop__TypeName, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool Navigate(
						global::System.__ComObject __this, 
						global::System.Type sourcePageType, 
						object parameter)
			{
				// Setup
				global::System.Type__Impl.UnsafeType unsafe_sourcePageType;
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_parameter = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				bool returnValue__retval;
				sbyte unsafe_returnValue__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					global::System.Runtime.InteropServices.HSTRING unsafe_sourcePageType__HSTRING__Name;
					int unsafe_sourcePageType__int__Kind;
					global::System.Runtime.InteropServices.McgMarshal.TypeToTypeName(
										sourcePageType, 
										out unsafe_sourcePageType__HSTRING__Name, 
										out unsafe_sourcePageType__int__Kind
									);
					unsafe_sourcePageType.Name = unsafe_sourcePageType__HSTRING__Name;
					unsafe_sourcePageType.Kind = (global::Windows.UI.Xaml.Interop.TypeKind)unsafe_sourcePageType__int__Kind;
					unsafe_parameter = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(parameter);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.IFrame).TypeHandle, 
										global::Windows.UI.Xaml.Controls.IFrame__Impl.Vtbl.idx_Navigate, 
										unsafe_sourcePageType, 
										unsafe_parameter, 
										&(unsafe_returnValue__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					returnValue__retval = unsafe_returnValue__retval != 0;
					// Return
					return returnValue__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_parameter)));
				}
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.IFrame'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrame))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.IFrame
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IFrame.Navigated")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IFrame.add_Navigated(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.add_Navigated(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IFrame.Navigated")]
			void global::Windows.UI.Xaml.Controls.IFrame.remove_Navigated(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.remove_Navigated(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IFrame.Navigating")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IFrame.add_Navigating(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.add_Navigating(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IFrame.Navigating")]
			void global::Windows.UI.Xaml.Controls.IFrame.remove_Navigating(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.remove_Navigating(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IFrame.NavigationFailed")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IFrame.add_NavigationFailed(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.add_NavigationFailed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IFrame.NavigationFailed")]
			void global::Windows.UI.Xaml.Controls.IFrame.remove_NavigationFailed(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.remove_NavigationFailed(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.IFrame.NavigationStopped")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.IFrame.add_NavigationStopped(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.add_NavigationStopped(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.IFrame.NavigationStopped")]
			void global::Windows.UI.Xaml.Controls.IFrame.remove_NavigationStopped(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.remove_NavigationStopped(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Controls.IFrame.Navigate(
						global::System.Type sourcePageType, 
						object parameter)
			{
				bool __retVal = global::Windows.UI.Xaml.Controls.IFrame__Impl.StubClass.Navigate(
									this, 
									sourcePageType, 
									parameter
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.IFrame'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrame))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_Navigated = 14;
			internal const int idx_remove_Navigated = 15;
			internal const int idx_add_Navigating = 16;
			internal const int idx_remove_Navigating = 17;
			internal const int idx_add_NavigationFailed = 18;
			internal const int idx_remove_NavigationFailed = 19;
			internal const int idx_add_NavigationStopped = 20;
			internal const int idx_remove_NavigationStopped = 21;
			internal const int idx_Navigate = 24;
		}
	}

	// Windows.UI.Xaml.Controls.INavigate
	public unsafe static class INavigate__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.INavigate'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.INavigate.Navigate, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTTypeNameMarshaller] System_Type__Windows_UI_Xaml_Interop__TypeName, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool Navigate(
						global::System.__ComObject __this, 
						global::System.Type sourcePageType)
			{
				// Setup
				global::System.Type__Impl.UnsafeType unsafe_sourcePageType;
				bool returnValue__retval;
				sbyte unsafe_returnValue__retval;
				int unsafe___return__;
				// Marshalling
				global::System.Runtime.InteropServices.HSTRING unsafe_sourcePageType__HSTRING__Name;
				int unsafe_sourcePageType__int__Kind;
				global::System.Runtime.InteropServices.McgMarshal.TypeToTypeName(
									sourcePageType, 
									out unsafe_sourcePageType__HSTRING__Name, 
									out unsafe_sourcePageType__int__Kind
								);
				unsafe_sourcePageType.Name = unsafe_sourcePageType__HSTRING__Name;
				unsafe_sourcePageType.Kind = (global::Windows.UI.Xaml.Interop.TypeKind)unsafe_sourcePageType__int__Kind;
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Controls.INavigate).TypeHandle, 
									global::Windows.UI.Xaml.Controls.INavigate__Impl.Vtbl.idx_Navigate, 
									unsafe_sourcePageType, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval != 0;
				// Return
				return returnValue__retval;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.INavigate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.INavigate))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.INavigate
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Controls.INavigate.Navigate(global::System.Type sourcePageType)
			{
				bool __retVal = global::Windows.UI.Xaml.Controls.INavigate__Impl.StubClass.Navigate(
									this, 
									sourcePageType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.INavigate'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.INavigate))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_Navigate = 6;
		}
	}

	// Windows.UI.Xaml.Controls.IFrame2
	public unsafe static class IFrame2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IFrame2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrame2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.IFrame3
	public unsafe static class IFrame3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.IFrame3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.IFrame3))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Xaml.Controls.Primitives
{
	// Windows.UI.Xaml.Controls.Primitives.IButtonBase
	public unsafe static class IButtonBase__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.Primitives.IButtonBase'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Click(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IButtonBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IButtonBase__Impl.Vtbl.idx_add_Click
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Click(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IButtonBase>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.Primitives.IButtonBase__Impl.Vtbl.idx_remove_Click
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.Primitives.IButtonBase'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IButtonBase))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.Primitives.IButtonBase
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.Primitives.IButtonBase.Click")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.Primitives.IButtonBase.add_Click(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.Primitives.IButtonBase__Impl.StubClass.add_Click(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.Primitives.IButtonBase.Click")]
			void global::Windows.UI.Xaml.Controls.Primitives.IButtonBase.remove_Click(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IButtonBase__Impl.StubClass.remove_Click(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IButtonBase'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IButtonBase))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_add_Click = 14;
			internal const int idx_remove_Click = 15;
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.IRangeBase
	public unsafe static class IRangeBase__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.Primitives.IRangeBase'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Minimum(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_put_Minimum
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_Maximum(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_get_Maximum
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Maximum(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_put_Maximum
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_SmallChange(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_get_SmallChange
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_SmallChange(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_put_SmallChange
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_LargeChange(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_get_LargeChange
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_LargeChange(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_put_LargeChange
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_Value(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_get_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Value(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_put_Value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Controls.Primitives.IRangeBase.add_ValueChanged, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_Controls_Primitives_RangeBaseValueChangedEventHandler__Windows_UI_Xaml_Controls_Primitives__RangeBaseValueChangedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ValueChanged(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget78>(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBase).TypeHandle, 
										global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_add_ValueChanged, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ValueChanged(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBase>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.Vtbl.idx_remove_ValueChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.Primitives.IRangeBase'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBase))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.Primitives.IRangeBase
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.Minimum")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.put_Minimum(double value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.put_Minimum(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.Maximum")]
			double global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.get_Maximum()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.get_Maximum(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.Maximum")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.put_Maximum(double value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.put_Maximum(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.SmallChange")]
			double global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.get_SmallChange()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.get_SmallChange(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.SmallChange")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.put_SmallChange(double value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.put_SmallChange(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.LargeChange")]
			double global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.get_LargeChange()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.get_LargeChange(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.LargeChange")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.put_LargeChange(double value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.put_LargeChange(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.Value")]
			double global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.get_Value()
			{
				double __retVal = global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.get_Value(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.Value")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.put_Value(double value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.put_Value(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.ValueChanged")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.add_ValueChanged(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.add_ValueChanged(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.Primitives.IRangeBase.ValueChanged")]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBase.remove_ValueChanged(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBase__Impl.StubClass.remove_ValueChanged(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IRangeBase'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBase))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_put_Minimum = 7;
			internal const int idx_get_Maximum = 8;
			internal const int idx_put_Maximum = 9;
			internal const int idx_get_SmallChange = 10;
			internal const int idx_put_SmallChange = 11;
			internal const int idx_get_LargeChange = 12;
			internal const int idx_put_LargeChange = 13;
			internal const int idx_get_Value = 14;
			internal const int idx_put_Value = 15;
			internal const int idx_add_ValueChanged = 16;
			internal const int idx_remove_ValueChanged = 17;
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler
	public unsafe static class RangeBaseValueChangedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler, global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Controls_Primitives__RangeBaseValueChangedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Controls_Primitives__RangeBaseValueChangedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Controls_Primitives_RangeBaseValueChangedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Controls_Primitives_RangeBaseValueChangedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Controls_Primitives__RangeBaseValueChangedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget79>(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Controls_Primitives_RangeBaseValueChangedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Controls_Primitives_RangeBaseValueChangedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs
	public unsafe static class IRangeBaseValueChangedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides
	public unsafe static class IRangeBaseOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnMinimumChanged(
						global::System.__ComObject __this, 
						double oldMinimum, 
						double newMinimum)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides>(
									__this, 
									oldMinimum, 
									newMinimum, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.Vtbl.idx_OnMinimumChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnMaximumChanged(
						global::System.__ComObject __this, 
						double oldMaximum, 
						double newMaximum)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides>(
									__this, 
									oldMaximum, 
									newMaximum, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.Vtbl.idx_OnMaximumChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnValueChanged(
						global::System.__ComObject __this, 
						double oldValue, 
						double newValue)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__double__<global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides>(
									__this, 
									oldValue, 
									newValue, 
									global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.Vtbl.idx_OnValueChanged
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides.OnMinimumChanged(
						double oldMinimum, 
						double newMinimum)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.StubClass.OnMinimumChanged(
									this, 
									oldMinimum, 
									newMinimum
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides.OnMaximumChanged(
						double oldMaximum, 
						double newMaximum)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.StubClass.OnMaximumChanged(
									this, 
									oldMaximum, 
									newMaximum
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides.OnValueChanged(
						double oldValue, 
						double newValue)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides__Impl.StubClass.OnValueChanged(
									this, 
									oldValue, 
									newValue
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnMinimumChanged = 6;
			internal const int idx_OnMaximumChanged = 7;
			internal const int idx_OnValueChanged = 8;
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.IToggleButton
	public unsafe static class IToggleButton__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.Primitives.IToggleButton'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Controls.Primitives.IToggleButton.get_IsChecked, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTReferenceMarshaller] System_Nullable_1_bool___Windows_Foundation__IReference_A_bool_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Nullable<bool> get_IsChecked(global::System.__ComObject __this)
			{
				// Setup
				global::System.Nullable_A_bool_V___Impl.Vtbl** unsafe_value__retval = default(global::System.Nullable_A_bool_V___Impl.Vtbl**);
				global::System.Nullable<bool> value__retval = default(global::System.Nullable<bool>);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButton).TypeHandle, 
										global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_get_IsChecked, 
										&(unsafe_value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_value__retval != null)
						value__retval = (bool)global::System.Runtime.InteropServices.McgModuleManager.UnboxIfBoxed(
											global::System.Runtime.InteropServices.McgModuleManager.ComInterfaceToObject_NoUnboxing(
																((global::System.IntPtr)unsafe_value__retval), 
																typeof(global::Windows.Foundation.IReference<bool>).TypeHandle
															), 
											"Windows.Foundation.IReference`1<Boolean>"
										);
					else
						value__retval = null;
					// Return
					return value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value__retval)));
				}
			}

			// Signature, Windows.UI.Xaml.Controls.Primitives.IToggleButton.put_IsChecked, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTReferenceMarshaller] System_Nullable_1_bool___Windows_Foundation__IReference_A_bool_V_ *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_IsChecked(
						global::System.__ComObject __this, 
						global::System.Nullable<bool> value)
			{
				// Setup
				global::System.Nullable_A_bool_V___Impl.Vtbl** unsafe_value = default(global::System.Nullable_A_bool_V___Impl.Vtbl**);
				int unsafe___return__;
				try
				{
					// Marshalling
					if (value.HasValue)
					{
						global::System.Runtime.InteropServices.WindowsRuntime.ReferenceImpl<bool> unsafe_value_Wrapper = new global::System.Runtime.InteropServices.WindowsRuntime.ReferenceImpl<bool>(value.Value, 11);
						unsafe_value = (global::System.Nullable_A_bool_V___Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ManagedObjectToComInterface(
											unsafe_value_Wrapper, 
											typeof(global::Windows.Foundation.IReference<bool>).TypeHandle
										);
					}
					else
						unsafe_value = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButton).TypeHandle, 
										global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_put_IsChecked, 
										unsafe_value
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Checked(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_add_Checked
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Checked(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_remove_Checked
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Unchecked(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_add_Unchecked
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Unchecked(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_remove_Unchecked
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_Indeterminate(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_add_Indeterminate
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_Indeterminate(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Controls.Primitives.IToggleButton>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.Vtbl.idx_remove_Indeterminate
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.Primitives.IToggleButton'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButton))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.Primitives.IToggleButton
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.IsChecked")]
			global::System.Nullable<bool> global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.get_IsChecked()
			{
				global::System.Nullable<bool> __retVal = global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.get_IsChecked(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.IsChecked")]
			void global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.put_IsChecked(global::System.Nullable<bool> value)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.put_IsChecked(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Checked")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.add_Checked(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.add_Checked(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Checked")]
			void global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.remove_Checked(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.remove_Checked(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Unchecked")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.add_Unchecked(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.add_Unchecked(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Unchecked")]
			void global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.remove_Unchecked(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.remove_Unchecked(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Indeterminate")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.add_Indeterminate(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.add_Indeterminate(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Controls.Primitives.IToggleButton.Indeterminate")]
			void global::Windows.UI.Xaml.Controls.Primitives.IToggleButton.remove_Indeterminate(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Controls.Primitives.IToggleButton__Impl.StubClass.remove_Indeterminate(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IToggleButton'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButton))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_IsChecked = 6;
			internal const int idx_put_IsChecked = 7;
			internal const int idx_add_Checked = 10;
			internal const int idx_remove_Checked = 11;
			internal const int idx_add_Unchecked = 12;
			internal const int idx_remove_Unchecked = 13;
			internal const int idx_add_Indeterminate = 14;
			internal const int idx_remove_Indeterminate = 15;
		}
	}

	// Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides
	public unsafe static class IToggleButtonOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnToggle(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides>(
									__this, 
									global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides__Impl.Vtbl.idx_OnToggle
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides.OnToggle()
			{
				global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides__Impl.StubClass.OnToggle(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnToggle = 6;
		}
	}
}

namespace Windows.UI.Xaml.Data
{
	// Windows.UI.Xaml.Data.IValueConverter
	public unsafe static class IValueConverter__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Data.IValueConverter'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object Convert(
						global::System.__ComObject __this, 
						object value, 
						global::System.Type targetType, 
						object parameter, 
						string language)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__Type__object__string__object__<global::Windows.UI.Xaml.Data.IValueConverter>(
									__this, 
									value, 
									targetType, 
									parameter, 
									language, 
									global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl.idx_Convert
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object ConvertBack(
						global::System.__ComObject __this, 
						object value, 
						global::System.Type targetType, 
						object parameter, 
						string language)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__Type__object__string__object__<global::Windows.UI.Xaml.Data.IValueConverter>(
									__this, 
									value, 
									targetType, 
									parameter, 
									language, 
									global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl.idx_ConvertBack
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Data.IValueConverter'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Data.IValueConverter))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Data.IValueConverter
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Data.IValueConverter.Convert(
						object value, 
						global::System.Type targetType, 
						object parameter, 
						string language)
			{
				object __retVal = global::Windows.UI.Xaml.Data.IValueConverter__Impl.StubClass.Convert(
									this, 
									value, 
									targetType, 
									parameter, 
									language
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Data.IValueConverter.ConvertBack(
						object value, 
						global::System.Type targetType, 
						object parameter, 
						string language)
			{
				object __retVal = global::Windows.UI.Xaml.Data.IValueConverter__Impl.StubClass.ConvertBack(
									this, 
									value, 
									targetType, 
									parameter, 
									language
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Data.IValueConverter'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Data.IValueConverter))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Data.IValueConverter))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Data__IValueConverter
			global::System.IntPtr pfnConvert_Windows_UI_Xaml_Data__IValueConverter;
			global::System.IntPtr pfnConvertBack_Windows_UI_Xaml_Data__IValueConverter;
			internal const int idx_Convert = 6;
			internal const int idx_ConvertBack = 7;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl.Windows_UI_Xaml_Data_IValueConverter__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Data_IValueConverter__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnConvert_Windows_UI_Xaml_Data__IValueConverter = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget3>(global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl.Convert__STUB),
				pfnConvertBack_Windows_UI_Xaml_Data__IValueConverter = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget3>(global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl.ConvertBack__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Convert__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value, 
						global::System.Type__Impl.UnsafeType unsafe_targetType, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_parameter, 
						global::System.Runtime.InteropServices.HSTRING unsafe_language, 
						global::System.Runtime.InteropServices.__vtable_IInspectable** unsafe_returnValue__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Data.IValueConverter>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_object__Type__object__string__object__(
									__this, 
									unsafe_value, 
									unsafe_targetType, 
									unsafe_parameter, 
									unsafe_language, 
									unsafe_returnValue__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int ConvertBack__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value, 
						global::System.Type__Impl.UnsafeType unsafe_targetType, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_parameter, 
						global::System.Runtime.InteropServices.HSTRING unsafe_language, 
						global::System.Runtime.InteropServices.__vtable_IInspectable** unsafe_returnValue__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Data.IValueConverter>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_object__Type__object__string__object__(
									__this, 
									unsafe_value, 
									unsafe_targetType, 
									unsafe_parameter, 
									unsafe_language, 
									unsafe_returnValue__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Data_IValueConverter__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl), "Convert__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.UI.Xaml.Data.IValueConverter__Impl.Vtbl), "ConvertBack__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Data_IValueConverter__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}
}

namespace Windows.UI.Xaml.Documents
{
	// Windows.UI.Xaml.Documents.ITextElement
	public unsafe static class ITextElement__Impl
	{
		// v-table for 'Windows.UI.Xaml.Documents.ITextElement'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ITextElement))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Documents.ITextElementOverrides
	public unsafe static class ITextElementOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Documents.ITextElementOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void OnDisconnectVisualChildren(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.Documents.ITextElementOverrides>(
									__this, 
									global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.Vtbl.idx_OnDisconnectVisualChildren
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Documents.ITextElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ITextElementOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Documents.ITextElementOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Documents.ITextElementOverrides.OnDisconnectVisualChildren()
			{
				global::Windows.UI.Xaml.Documents.ITextElementOverrides__Impl.StubClass.OnDisconnectVisualChildren(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Documents.ITextElementOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ITextElementOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_OnDisconnectVisualChildren = 6;
		}
	}

	// Windows.UI.Xaml.Documents.ITextElement2
	public unsafe static class ITextElement2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Documents.ITextElement2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ITextElement2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Documents.ITextElement3
	public unsafe static class ITextElement3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Documents.ITextElement3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ITextElement3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Documents.IInline
	public unsafe static class IInline__Impl
	{
		// v-table for 'Windows.UI.Xaml.Documents.IInline'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.IInline))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Documents.IRun
	public unsafe static class IRun__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Documents.IRun'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Text(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Documents.IRun>(
									__this, 
									global::Windows.UI.Xaml.Documents.IRun__Impl.Vtbl.idx_get_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Text(
						global::System.__ComObject __this, 
						string value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_string__<global::Windows.UI.Xaml.Documents.IRun>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Documents.IRun__Impl.Vtbl.idx_put_Text
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Documents.IRun'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.IRun))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Documents.IRun
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Documents.IRun.Text")]
			string global::Windows.UI.Xaml.Documents.IRun.get_Text()
			{
				string __retVal = global::Windows.UI.Xaml.Documents.IRun__Impl.StubClass.get_Text(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Documents.IRun.Text")]
			void global::Windows.UI.Xaml.Documents.IRun.put_Text(string value)
			{
				global::Windows.UI.Xaml.Documents.IRun__Impl.StubClass.put_Text(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Documents.IRun'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.IRun))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Text = 6;
			internal const int idx_put_Text = 7;
		}
	}

	// Windows.UI.Xaml.Documents.ILineBreak
	public unsafe static class ILineBreak__Impl
	{
		// v-table for 'Windows.UI.Xaml.Documents.ILineBreak'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Documents.ILineBreak))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Xaml.Input
{
	// Windows.UI.Xaml.Input.KeyEventHandler
	public unsafe static class KeyEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.KeyRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.KeyEventHandler, global::Windows.UI.Xaml.Input.KeyRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.KeyEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.KeyEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__KeyEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__KeyEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_KeyEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_KeyEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__KeyEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget37>(global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IKeyRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.KeyEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.KeyRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_KeyEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.KeyEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_KeyEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IKeyRoutedEventArgs
	public unsafe static class IKeyRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IKeyRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IKeyRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IKeyRoutedEventArgs2
	public unsafe static class IKeyRoutedEventArgs2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IKeyRoutedEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IKeyRoutedEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IKeyRoutedEventArgs3
	public unsafe static class IKeyRoutedEventArgs3__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IKeyRoutedEventArgs3'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IKeyRoutedEventArgs3))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.PointerEventHandler
	public unsafe static class PointerEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.PointerEventHandler, global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.PointerEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.PointerEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__PointerEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__PointerEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_PointerEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_PointerEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__PointerEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget40>(global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IPointerRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.PointerEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.PointerRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_PointerEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.PointerEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_PointerEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IPointerRoutedEventArgs
	public unsafe static class IPointerRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IPointerRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IPointerRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.TappedEventHandler
	public unsafe static class TappedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.TappedRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.TappedEventHandler, global::Windows.UI.Xaml.Input.TappedRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.TappedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.TappedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__TappedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__TappedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_TappedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_TappedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__TappedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget41>(global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.ITappedRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.TappedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.TappedRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_TappedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.TappedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_TappedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.ITappedRoutedEventArgs
	public unsafe static class ITappedRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.ITappedRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.ITappedRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.DoubleTappedEventHandler
	public unsafe static class DoubleTappedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.DoubleTappedEventHandler, global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.DoubleTappedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__DoubleTappedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__DoubleTappedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_DoubleTappedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_DoubleTappedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__DoubleTappedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget42>(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IDoubleTappedRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.DoubleTappedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_DoubleTappedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.DoubleTappedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_DoubleTappedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IDoubleTappedRoutedEventArgs
	public unsafe static class IDoubleTappedRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IDoubleTappedRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IDoubleTappedRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.HoldingEventHandler
	public unsafe static class HoldingEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.HoldingEventHandler, global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.HoldingEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.HoldingEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__HoldingEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__HoldingEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_HoldingEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_HoldingEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__HoldingEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget43>(global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IHoldingRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.HoldingEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.HoldingRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_HoldingEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.HoldingEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_HoldingEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IHoldingRoutedEventArgs
	public unsafe static class IHoldingRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IHoldingRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IHoldingRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.RightTappedEventHandler
	public unsafe static class RightTappedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.RightTappedEventHandler, global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.RightTappedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.RightTappedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__RightTappedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__RightTappedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_RightTappedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_RightTappedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__RightTappedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget44>(global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IRightTappedRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.RightTappedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.RightTappedRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_RightTappedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.RightTappedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_RightTappedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IRightTappedRoutedEventArgs
	public unsafe static class IRightTappedRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IRightTappedRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IRightTappedRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.ManipulationStartingEventHandler
	public unsafe static class ManipulationStartingEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler, global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.ManipulationStartingEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__ManipulationStartingEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__ManipulationStartingEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_ManipulationStartingEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_ManipulationStartingEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__ManipulationStartingEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget45>(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IManipulationStartingRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_ManipulationStartingEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.ManipulationStartingEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_ManipulationStartingEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IManipulationStartingRoutedEventArgs
	public unsafe static class IManipulationStartingRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IManipulationStartingRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IManipulationStartingRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler
	public unsafe static class ManipulationInertiaStartingEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler, global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__ManipulationInertiaStartingEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__ManipulationInertiaStartingEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_ManipulationInertiaStartingEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_ManipulationInertiaStartingEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__ManipulationInertiaStartingEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget46>(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_ManipulationInertiaStartingEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_ManipulationInertiaStartingEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs
	public unsafe static class IManipulationInertiaStartingRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.ManipulationStartedEventHandler
	public unsafe static class ManipulationStartedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler, global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.ManipulationStartedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__ManipulationStartedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__ManipulationStartedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_ManipulationStartedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_ManipulationStartedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__ManipulationStartedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget47>(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IManipulationStartedRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_ManipulationStartedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.ManipulationStartedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_ManipulationStartedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IManipulationStartedRoutedEventArgs
	public unsafe static class IManipulationStartedRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IManipulationStartedRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IManipulationStartedRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.ManipulationDeltaEventHandler
	public unsafe static class ManipulationDeltaEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler, global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.ManipulationDeltaEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__ManipulationDeltaEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__ManipulationDeltaEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_ManipulationDeltaEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_ManipulationDeltaEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__ManipulationDeltaEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget48>(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_ManipulationDeltaEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.ManipulationDeltaEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_ManipulationDeltaEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs
	public unsafe static class IManipulationDeltaRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.ManipulationCompletedEventHandler
	public unsafe static class ManipulationCompletedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler, global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Input.ManipulationCompletedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Input__ManipulationCompletedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Input__ManipulationCompletedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Input_ManipulationCompletedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Input_ManipulationCompletedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Input__ManipulationCompletedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget49>(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Input_ManipulationCompletedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Input.ManipulationCompletedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Input_ManipulationCompletedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs
	public unsafe static class IManipulationCompletedRoutedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IContextRequestedEventArgs
	public unsafe static class IContextRequestedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IContextRequestedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IContextRequestedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs
	public unsafe static class IAccessKeyDisplayRequestedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs
	public unsafe static class IAccessKeyDisplayDismissedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Input.IAccessKeyInvokedEventArgs
	public unsafe static class IAccessKeyInvokedEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Input.IAccessKeyInvokedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Input.IAccessKeyInvokedEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}
}

namespace Windows.UI.Xaml.Markup
{
	// Windows.UI.Xaml.Markup.IComponentConnector
	public unsafe static class IComponentConnector__Impl
	{
		// v-table for 'Windows.UI.Xaml.Markup.IComponentConnector'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Markup__IComponentConnector
			global::System.IntPtr pfnConnect_Windows_UI_Xaml_Markup__IComponentConnector;
			internal const int idx_Connect = 6;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl.Windows_UI_Xaml_Markup_IComponentConnector__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Markup_IComponentConnector__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnConnect_Windows_UI_Xaml_Markup__IComponentConnector = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget100>(global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl.Connect__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, Windows.UI.Xaml.Markup.IComponentConnector.Connect, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Connect__STUB(
						global::System.IntPtr pComThis, 
						int unsafe_connectionId, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_target)
			{
				// Setup
				object target = default(object);
				try
				{
					// Marshalling
					target = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_target));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IComponentConnector>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).Connect(
										unsafe_connectionId, 
										target
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			private static class Windows_UI_Xaml_Markup_IComponentConnector__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl), "Connect__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Markup_IComponentConnector__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Markup.IComponentConnector2
	public unsafe static class IComponentConnector2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Markup.IComponentConnector2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector2))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector2))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Markup__IComponentConnector2
			global::System.IntPtr pfnGetBindingConnector_Windows_UI_Xaml_Markup__IComponentConnector2;
			internal const int idx_GetBindingConnector = 6;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Markup.IComponentConnector2__Impl.Vtbl.Windows_UI_Xaml_Markup_IComponentConnector2__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Markup_IComponentConnector2__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Markup.IComponentConnector2__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Markup.IComponentConnector2__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnGetBindingConnector_Windows_UI_Xaml_Markup__IComponentConnector2 = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget101>(global::Windows.UI.Xaml.Markup.IComponentConnector2__Impl.Vtbl.GetBindingConnector__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, Windows.UI.Xaml.Markup.IComponentConnector2.GetBindingConnector, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.BlittableValueMarshaller] int__int, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Markup_IComponentConnector__Windows_UI_Xaml_Markup__IComponentConnector *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetBindingConnector__STUB(
						global::System.IntPtr pComThis, 
						int unsafe_connectionId, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_target, 
						global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl*** unsafe_returnValue__retval)
			{
				// Setup
				object target = default(object);
				if (unsafe_returnValue__retval != null)
					(*(unsafe_returnValue__retval)) = null;
				global::Windows.UI.Xaml.Markup.IComponentConnector returnValue__retval = default(global::Windows.UI.Xaml.Markup.IComponentConnector);
				try
				{
					// Marshalling
					target = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_target));
					// Call to managed method
					returnValue__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IComponentConnector2>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetBindingConnector(
										unsafe_connectionId, 
										target
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_returnValue__retval != null)
						(*(unsafe_returnValue__retval)) = (global::Windows.UI.Xaml.Markup.IComponentConnector__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
											returnValue__retval, 
											typeof(global::Windows.UI.Xaml.Markup.IComponentConnector).TypeHandle
										);
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_returnValue__retval != null)
					{
						global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)(*(unsafe_returnValue__retval)))));
						(*(unsafe_returnValue__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			private static class Windows_UI_Xaml_Markup_IComponentConnector2__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Markup.IComponentConnector2__Impl.Vtbl), "GetBindingConnector__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Markup_IComponentConnector2__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Markup.IXamlMetadataProvider
	public unsafe static class IXamlMetadataProvider__Impl
	{
		// v-table for 'Windows.UI.Xaml.Markup.IXamlMetadataProvider'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Markup__IXamlMetadataProvider
			global::System.IntPtr pfnGetXamlType_Windows_UI_Xaml_Markup__IXamlMetadataProvider;
			global::System.IntPtr pfnGetXamlTypeByFullName_Windows_UI_Xaml_Markup__IXamlMetadataProvider;
			global::System.IntPtr pfnGetXmlnsDefinitions_Windows_UI_Xaml_Markup__IXamlMetadataProvider;
			internal const int idx_GetXamlType = 6;
			internal const int idx_GetXamlTypeByFullName = 7;
			internal const int idx_GetXmlnsDefinitions = 8;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl.Windows_UI_Xaml_Markup_IXamlMetadataProvider__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Markup_IXamlMetadataProvider__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnGetXamlType_Windows_UI_Xaml_Markup__IXamlMetadataProvider = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget102>(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl.GetXamlType__STUB),
				pfnGetXamlTypeByFullName_Windows_UI_Xaml_Markup__IXamlMetadataProvider = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget103>(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl.GetXamlTypeByFullName__STUB),
				pfnGetXmlnsDefinitions_Windows_UI_Xaml_Markup__IXamlMetadataProvider = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget104>(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl.GetXmlnsDefinitions__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			// Signature, Windows.UI.Xaml.Markup.IXamlMetadataProvider.GetXamlType, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.WinRTTypeNameMarshaller] System_Type__Windows_UI_Xaml_Interop__TypeName, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.ComInterfaceMarshaller] Windows_UI_Xaml_Markup_IXamlType__Windows_UI_Xaml_Markup__IXamlType *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetXamlType__STUB(
						global::System.IntPtr pComThis, 
						global::System.Type__Impl.UnsafeType unsafe_type, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_xamlType__retval)
			{
				// Setup
				global::System.Type type;
				if (unsafe_xamlType__retval != null)
					(*(unsafe_xamlType__retval)) = null;
				global::Windows.UI.Xaml.Markup.IXamlType xamlType__retval = default(global::Windows.UI.Xaml.Markup.IXamlType);
				try
				{
					// Marshalling
					type = global::System.Runtime.InteropServices.McgMarshal.TypeNameToType(
										unsafe_type.Name, 
										((int)unsafe_type.Kind)
									);
					// Call to managed method
					xamlType__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlMetadataProvider>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetXamlType(type);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_xamlType__retval != null)
						(*(unsafe_xamlType__retval)) = (global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.ObjectToComInterface(
											xamlType__retval, 
											typeof(global::Windows.UI.Xaml.Markup.IXamlType).TypeHandle
										);
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_xamlType__retval != null)
					{
						global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)(*(unsafe_xamlType__retval)))));
						(*(unsafe_xamlType__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetXamlTypeByFullName__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING unsafe_fullName, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_xamlType__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMetadataProvider>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_string__TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									unsafe_fullName, 
									((void**)unsafe_xamlType__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlMetadataProvider.GetXmlnsDefinitions, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.ArrayMarshaller] [hal]rg_Windows_UI_Xaml_Markup_XmlnsDefinition__Windows_UI_Xaml_Markup__XmlnsDefinition *, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetXmlnsDefinitions__STUB(
						global::System.IntPtr pComThis, 
						uint* unsafe_definitions__retval_mcgLength, 
						global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType** unsafe_definitions__retval)
			{
				// Setup
				if (unsafe_definitions__retval != null)
					(*(unsafe_definitions__retval)) = null;
				global::Windows.UI.Xaml.Markup.XmlnsDefinition[] definitions__retval = default(global::Windows.UI.Xaml.Markup.XmlnsDefinition[]);
				try
				{
					// Marshalling
					// Call to managed method
					definitions__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlMetadataProvider>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetXmlnsDefinitions();
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_definitions__retval != null)
						if (definitions__retval == null)
							(*(unsafe_definitions__retval)) = null;
						else
						{
							if (definitions__retval != null)
								(*(unsafe_definitions__retval_mcgLength)) = (uint)definitions__retval.Length;
							if (definitions__retval != null)
								(*(unsafe_definitions__retval)) = (global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType*)global::McgInterop.McgHelpers.CoTaskMemAllocAndZeroMemory(((global::System.IntPtr)checked((*(unsafe_definitions__retval_mcgLength)) * sizeof(global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType))));
							if (definitions__retval != null)
								for (uint mcgIdx = 0; (mcgIdx < (*(unsafe_definitions__retval_mcgLength))); mcgIdx++)
								{
									// [rev] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.StructMarshaller] Windows_UI_Xaml_Markup_XmlnsDefinition__Windows_UI_Xaml_Markup__XmlnsDefinition definitions__retval
									global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.Marshal__SafeToUnsafe(
														ref definitions__retval[mcgIdx], 
														out (*(unsafe_definitions__retval))[mcgIdx]
													);
								}
						}
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_definitions__retval != null)
					{
						if ((*(unsafe_definitions__retval)) != null)
							for (uint mcgIdx_1 = 0; (mcgIdx_1 < (*(unsafe_definitions__retval_mcgLength))); mcgIdx_1++)
							{
								// [fwd] [in] [out] [retval] [nativebyref] [optional] [Mcg.CodeGen.StructMarshaller] Windows_UI_Xaml_Markup_XmlnsDefinition__Windows_UI_Xaml_Markup__XmlnsDefinition definitions__retval
								global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.Cleanup__Unsafe(ref (*(unsafe_definitions__retval))[mcgIdx_1]);
							}
						global::System.Runtime.InteropServices.ExternalInterop.SafeCoTaskMemFree((*(unsafe_definitions__retval)));
						(*(unsafe_definitions__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			private static class Windows_UI_Xaml_Markup_IXamlMetadataProvider__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl), "GetXamlType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl), "GetXamlTypeByFullName__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::Windows.UI.Xaml.Markup.IXamlMetadataProvider__Impl.Vtbl), "GetXmlnsDefinitions__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Markup_IXamlMetadataProvider__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Markup.IXamlType
	public unsafe static class IXamlType__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Markup.IXamlType'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_BaseType(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_BaseType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlMember get_ContentProperty(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType, global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_ContentProperty
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_FullName(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_FullName
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsArray(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsArray
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsCollection(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsCollection
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsConstructible(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsConstructible
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsDictionary(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsDictionary
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsMarkupExtension(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsMarkupExtension
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsBindable(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_IsBindable
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_ItemType(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_ItemType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_KeyType(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_KeyType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Type get_UnderlyingType(global::System.__ComObject __this)
			{
				global::System.Type __ret = global::McgInterop.ForwardComSharedStubs.Func_Type__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_get_UnderlyingType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object ActivateInstance(global::System.__ComObject __this)
			{
				object __ret = global::McgInterop.ForwardComSharedStubs.Func_object__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_ActivateInstance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.CreateFromString, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object CreateFromString(
						global::System.__ComObject __this, 
						string value)
			{
				// Setup
				global::System.Runtime.InteropServices.HSTRING unsafe_value = default(global::System.Runtime.InteropServices.HSTRING);
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance__retval = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				object instance__retval = default(object);
				int unsafe___return__;
				try
				{
					// Marshalling
					fixed (char* pBuffer_value = value)
					{
						global::System.Runtime.InteropServices.HSTRING_HEADER hstring_header_value;
						global::System.Runtime.InteropServices.McgMarshal.StringToHStringReference(pBuffer_value, value, &(hstring_header_value), &(unsafe_value));
						unsafe_instance__retval = null;
						// Call to native method
						unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
											__this, 
											typeof(global::Windows.UI.Xaml.Markup.IXamlType).TypeHandle, 
											global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_CreateFromString, 
											unsafe_value, 
											&(unsafe_instance__retval)
										);
						global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
						instance__retval = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_instance__retval));
					}
					// Return
					return instance__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_instance__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlMember GetMember(
						global::System.__ComObject __this, 
						string name)
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __ret = global::McgInterop.ForwardComSharedStubs.Func_string__TResult__<global::Windows.UI.Xaml.Markup.IXamlType, global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									name, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_GetMember
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void AddToVector(
						global::System.__ComObject __this, 
						object instance, 
						object value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_object__object__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									instance, 
									value, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_AddToVector
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.AddToMap, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void AddToMap(
						global::System.__ComObject __this, 
						object instance, 
						object key, 
						object value)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_key = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_instance = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(instance);
					unsafe_key = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(key);
					unsafe_value = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(value);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Markup.IXamlType).TypeHandle, 
										global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_AddToMap, 
										unsafe_instance, 
										unsafe_key, 
										unsafe_value
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_instance)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_key)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void RunInitializer(global::System.__ComObject __this)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.idx_RunInitializer
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Markup.IXamlType'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IXamlType))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Markup.IXamlType
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.BaseType")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.UI.Xaml.Markup.IXamlType.get_BaseType()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_BaseType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.ContentProperty")]
			global::Windows.UI.Xaml.Markup.IXamlMember global::Windows.UI.Xaml.Markup.IXamlType.get_ContentProperty()
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_ContentProperty(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.FullName")]
			string global::Windows.UI.Xaml.Markup.IXamlType.get_FullName()
			{
				string __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_FullName(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsArray")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsArray()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsArray(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsCollection")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsCollection()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsCollection(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsConstructible")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsConstructible()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsConstructible(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsDictionary")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsDictionary()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsDictionary(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsMarkupExtension")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsMarkupExtension()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsMarkupExtension(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.IsBindable")]
			bool global::Windows.UI.Xaml.Markup.IXamlType.get_IsBindable()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_IsBindable(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.ItemType")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.UI.Xaml.Markup.IXamlType.get_ItemType()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_ItemType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.KeyType")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.UI.Xaml.Markup.IXamlType.get_KeyType()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_KeyType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlType.UnderlyingType")]
			global::System.Type global::Windows.UI.Xaml.Markup.IXamlType.get_UnderlyingType()
			{
				global::System.Type __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.get_UnderlyingType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Markup.IXamlType.ActivateInstance()
			{
				object __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.ActivateInstance(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Markup.IXamlType.CreateFromString(string value)
			{
				object __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.CreateFromString(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.UI.Xaml.Markup.IXamlMember global::Windows.UI.Xaml.Markup.IXamlType.GetMember(string name)
			{
				global::Windows.UI.Xaml.Markup.IXamlMember __retVal = global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.GetMember(
									this, 
									name
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Markup.IXamlType.AddToVector(
						object instance, 
						object value)
			{
				global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.AddToVector(
									this, 
									instance, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Markup.IXamlType.AddToMap(
						object instance, 
						object key, 
						object value)
			{
				global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.AddToMap(
									this, 
									instance, 
									key, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Markup.IXamlType.RunInitializer()
			{
				global::Windows.UI.Xaml.Markup.IXamlType__Impl.StubClass.RunInitializer(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Markup.IXamlType'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IXamlType))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Markup.IXamlType))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Markup__IXamlType
			global::System.IntPtr pfnget_BaseType_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_ContentProperty_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_FullName_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsArray_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsCollection_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsConstructible_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsDictionary_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsMarkupExtension_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_IsBindable_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_ItemType_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_KeyType_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnget_UnderlyingType_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnActivateInstance_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnCreateFromString_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnGetMember_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnAddToVector_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnAddToMap_Windows_UI_Xaml_Markup__IXamlType;
			global::System.IntPtr pfnRunInitializer_Windows_UI_Xaml_Markup__IXamlType;
			internal const int idx_get_BaseType = 6;
			internal const int idx_get_ContentProperty = 7;
			internal const int idx_get_FullName = 8;
			internal const int idx_get_IsArray = 9;
			internal const int idx_get_IsCollection = 10;
			internal const int idx_get_IsConstructible = 11;
			internal const int idx_get_IsDictionary = 12;
			internal const int idx_get_IsMarkupExtension = 13;
			internal const int idx_get_IsBindable = 14;
			internal const int idx_get_ItemType = 15;
			internal const int idx_get_KeyType = 16;
			internal const int idx_get_UnderlyingType = 17;
			internal const int idx_ActivateInstance = 18;
			internal const int idx_CreateFromString = 19;
			internal const int idx_GetMember = 20;
			internal const int idx_AddToVector = 21;
			internal const int idx_AddToMap = 22;
			internal const int idx_RunInitializer = 23;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.Windows_UI_Xaml_Markup_IXamlType__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Markup_IXamlType__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnget_BaseType_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget105>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_BaseType__STUB),
				pfnget_ContentProperty_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget106>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_ContentProperty__STUB),
				pfnget_FullName_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget2>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_FullName__STUB),
				pfnget_IsArray_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsArray__STUB),
				pfnget_IsCollection_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsCollection__STUB),
				pfnget_IsConstructible_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsConstructible__STUB),
				pfnget_IsDictionary_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsDictionary__STUB),
				pfnget_IsMarkupExtension_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsMarkupExtension__STUB),
				pfnget_IsBindable_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_IsBindable__STUB),
				pfnget_ItemType_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget105>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_ItemType__STUB),
				pfnget_KeyType_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget105>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_KeyType__STUB),
				pfnget_UnderlyingType_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget108>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.get_UnderlyingType__STUB),
				pfnActivateInstance_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget109>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.ActivateInstance__STUB),
				pfnCreateFromString_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget110>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.CreateFromString__STUB),
				pfnGetMember_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget111>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.GetMember__STUB),
				pfnAddToVector_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget112>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.AddToVector__STUB),
				pfnAddToMap_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget113>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.AddToMap__STUB),
				pfnRunInitializer_Windows_UI_Xaml_Markup__IXamlType = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget114>(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl.RunInitializer__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_BaseType__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_ContentProperty__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_FullName__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									2
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_string__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsArray__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									3
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsCollection__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									4
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsConstructible__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									5
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsDictionary__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									6
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsMarkupExtension__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									7
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsBindable__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									8
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_ItemType__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									9
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_KeyType__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									10
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.get_UnderlyingType, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTTypeNameMarshaller] System_Type__Windows_UI_Xaml_Interop__TypeName, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_UnderlyingType__STUB(
						global::System.IntPtr pComThis, 
						global::System.Type__Impl.UnsafeType* unsafe_value__retval)
			{
				// Setup
				global::System.Type value__retval;
				try
				{
					// Marshalling
					// Call to managed method
					value__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlType>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).get_UnderlyingType();
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_value__retval != null)
					{
						global::System.Runtime.InteropServices.HSTRING unsafe_value__retval__HSTRING__Name;
						int unsafe_value__retval__int__Kind;
						global::System.Runtime.InteropServices.McgMarshal.TypeToTypeName(
											value__retval, 
											out unsafe_value__retval__HSTRING__Name, 
											out unsafe_value__retval__int__Kind
										);
						(*(unsafe_value__retval)).Name = unsafe_value__retval__HSTRING__Name;
						(*(unsafe_value__retval)).Kind = (global::Windows.UI.Xaml.Interop.TypeKind)unsafe_value__retval__int__Kind;
					}
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_value__retval != null)
						(*(unsafe_value__retval)) = default(global::System.Type__Impl.UnsafeType);
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.ActivateInstance, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int ActivateInstance__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable** unsafe_instance__retval)
			{
				// Setup
				if (unsafe_instance__retval != null)
					(*(unsafe_instance__retval)) = null;
				object instance__retval = default(object);
				try
				{
					// Marshalling
					// Call to managed method
					instance__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlType>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).ActivateInstance();
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_instance__retval != null)
						(*(unsafe_instance__retval)) = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(instance__retval);
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_instance__retval != null)
					{
						global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)(*(unsafe_instance__retval)))));
						(*(unsafe_instance__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.CreateFromString, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int CreateFromString__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING unsafe_value, 
						global::System.Runtime.InteropServices.__vtable_IInspectable** unsafe_instance__retval)
			{
				// Setup
				string value = default(string);
				if (unsafe_instance__retval != null)
					(*(unsafe_instance__retval)) = null;
				object instance__retval = default(object);
				try
				{
					// Marshalling
					value = global::System.Runtime.InteropServices.McgMarshal.HStringToString(unsafe_value);
					// Call to managed method
					instance__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlType>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).CreateFromString(value);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_instance__retval != null)
						(*(unsafe_instance__retval)) = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(instance__retval);
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_instance__retval != null)
					{
						global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)(*(unsafe_instance__retval)))));
						(*(unsafe_instance__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetMember__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING unsafe_name, 
						global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl*** unsafe_xamlMember__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									14
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_string__TResult__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									unsafe_name, 
									((void**)unsafe_xamlMember__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int AddToVector__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									15
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__object__(
									__this, 
									unsafe_instance, 
									unsafe_value, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlType.AddToMap, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int AddToMap__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_key, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value)
			{
				// Setup
				object instance = default(object);
				object key = default(object);
				object value = default(object);
				try
				{
					// Marshalling
					instance = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_instance));
					key = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_key));
					value = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_value));
					// Call to managed method
					global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlType>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).AddToMap(
										instance, 
										key, 
										value
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int RunInitializer__STUB(global::System.IntPtr pComThis)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									17
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_(
									__this, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Markup_IXamlType__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_BaseType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_ContentProperty__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_FullName__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(36, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsArray__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(40, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsCollection__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(44, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsConstructible__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(48, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsDictionary__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(52, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsMarkupExtension__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(56, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_IsBindable__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(60, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_ItemType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(64, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_KeyType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(68, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "get_UnderlyingType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(72, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "ActivateInstance__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(76, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "CreateFromString__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(80, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "GetMember__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(84, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "AddToVector__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(88, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "AddToMap__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(92, typeof(global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl), "RunInitializer__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Markup_IXamlType__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Markup.IXamlMember
	public unsafe static class IXamlMember__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Markup.IXamlMember'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsAttachable(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_IsAttachable
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsDependencyProperty(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_IsDependencyProperty
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool get_IsReadOnly(global::System.__ComObject __this)
			{
				bool __ret = global::McgInterop.ForwardComSharedStubs.Func_bool__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_IsReadOnly
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static string get_Name(global::System.__ComObject __this)
			{
				string __ret = global::McgInterop.ForwardComSharedStubs.Func_string__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_Name
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_TargetType(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlMember, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_TargetType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Markup.IXamlType get_Type(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Markup.IXamlType __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlMember, global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_get_Type
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlMember.GetValue, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static object GetValue(
						global::System.__ComObject __this, 
						object instance)
			{
				// Setup
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value__retval = default(global::System.Runtime.InteropServices.__vtable_IInspectable*);
				object value__retval = default(object);
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_instance = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(instance);
					unsafe_value__retval = null;
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Markup.IXamlMember).TypeHandle, 
										global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_GetValue, 
										unsafe_instance, 
										&(unsafe_value__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					value__retval = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_value__retval));
					// Return
					return value__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_instance)));
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value__retval)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void SetValue(
						global::System.__ComObject __this, 
						object instance, 
						object value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_object__object__<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									instance, 
									value, 
									global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.idx_SetValue
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Markup.IXamlMember'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IXamlMember))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Markup.IXamlMember
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.IsAttachable")]
			bool global::Windows.UI.Xaml.Markup.IXamlMember.get_IsAttachable()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_IsAttachable(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.IsDependencyProperty")]
			bool global::Windows.UI.Xaml.Markup.IXamlMember.get_IsDependencyProperty()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_IsDependencyProperty(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.IsReadOnly")]
			bool global::Windows.UI.Xaml.Markup.IXamlMember.get_IsReadOnly()
			{
				bool __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_IsReadOnly(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.Name")]
			string global::Windows.UI.Xaml.Markup.IXamlMember.get_Name()
			{
				string __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_Name(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.TargetType")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.UI.Xaml.Markup.IXamlMember.get_TargetType()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_TargetType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Markup.IXamlMember.Type")]
			global::Windows.UI.Xaml.Markup.IXamlType global::Windows.UI.Xaml.Markup.IXamlMember.get_Type()
			{
				global::Windows.UI.Xaml.Markup.IXamlType __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.get_Type(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			object global::Windows.UI.Xaml.Markup.IXamlMember.GetValue(object instance)
			{
				object __retVal = global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.GetValue(
									this, 
									instance
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			void global::Windows.UI.Xaml.Markup.IXamlMember.SetValue(
						object instance, 
						object value)
			{
				global::Windows.UI.Xaml.Markup.IXamlMember__Impl.StubClass.SetValue(
									this, 
									instance, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Markup.IXamlMember'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Markup.IXamlMember))]
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Markup.IXamlMember))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			global::System.IntPtr pfnGetIids;
			global::System.IntPtr pfnGetRuntimeClassName;
			global::System.IntPtr pfnGetTrustLevel;
			// Windows_UI_Xaml_Markup__IXamlMember
			global::System.IntPtr pfnget_IsAttachable_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnget_IsDependencyProperty_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnget_IsReadOnly_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnget_Name_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnget_TargetType_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnget_Type_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnGetValue_Windows_UI_Xaml_Markup__IXamlMember;
			global::System.IntPtr pfnSetValue_Windows_UI_Xaml_Markup__IXamlMember;
			internal const int idx_get_IsAttachable = 6;
			internal const int idx_get_IsDependencyProperty = 7;
			internal const int idx_get_IsReadOnly = 8;
			internal const int idx_get_Name = 9;
			internal const int idx_get_TargetType = 10;
			internal const int idx_get_Type = 11;
			internal const int idx_GetValue = 12;
			internal const int idx_SetValue = 13;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.Windows_UI_Xaml_Markup_IXamlMember__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Markup_IXamlMember__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnGetIids = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget0>(System.Runtime.InteropServices.__vtable_IInspectable.GetIIDs),
				pfnGetRuntimeClassName = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetRuntimeClassName),
				pfnGetTrustLevel = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget1>(System.Runtime.InteropServices.__vtable_IInspectable.GetTrustLevel),
				pfnget_IsAttachable_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_IsAttachable__STUB),
				pfnget_IsDependencyProperty_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_IsDependencyProperty__STUB),
				pfnget_IsReadOnly_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget107>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_IsReadOnly__STUB),
				pfnget_Name_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget2>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_Name__STUB),
				pfnget_TargetType_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget105>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_TargetType__STUB),
				pfnget_Type_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget105>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.get_Type__STUB),
				pfnGetValue_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget115>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.GetValue__STUB),
				pfnSetValue_Windows_UI_Xaml_Markup__IXamlMember = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget112>(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl.SetValue__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsAttachable__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsDependencyProperty__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									1
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_IsReadOnly__STUB(
						global::System.IntPtr pComThis, 
						sbyte* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									2
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_bool__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_Name__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.HSTRING* unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									3
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_string__(
									__this, 
									unsafe_value__retval, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_TargetType__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									4
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int get_Type__STUB(
						global::System.IntPtr pComThis, 
						global::Windows.UI.Xaml.Markup.IXamlType__Impl.Vtbl*** unsafe_value__retval)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									5
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Markup.IXamlType>(
									__this, 
									((void**)unsafe_value__retval), 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Markup.IXamlMember.GetValue, [rev] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [rev] [in] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, [rev] [out] [retval] [nativebyref] [Mcg.CodeGen.WinRTInspectableMarshaller] object____mcg_IInspectable, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int GetValue__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance, 
						global::System.Runtime.InteropServices.__vtable_IInspectable** unsafe_value__retval)
			{
				// Setup
				object instance = default(object);
				if (unsafe_value__retval != null)
					(*(unsafe_value__retval)) = null;
				object value__retval = default(object);
				try
				{
					// Marshalling
					instance = global::System.Runtime.InteropServices.McgMarshal.IInspectableToObject(((global::System.IntPtr)unsafe_instance));
					// Call to managed method
					value__retval = global::System.Runtime.InteropServices.McgMarshal.FastCast<global::Windows.UI.Xaml.Markup.IXamlMember>(global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis)).GetValue(instance);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					if (unsafe_value__retval != null)
						(*(unsafe_value__retval)) = (global::System.Runtime.InteropServices.__vtable_IInspectable*)global::System.Runtime.InteropServices.McgMarshal.ObjectToIInspectable(value__retval);
					// Return
					return global::McgInterop.Helpers.S_OK;
				}
				catch (global::System.Exception hrExcep)
				{
					// ExceptionCleanup
					if (unsafe_value__retval != null)
					{
						global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)(*(unsafe_value__retval)))));
						(*(unsafe_value__retval)) = null;
					}
					// ExceptionReturn
					return global::System.Runtime.InteropServices.McgMarshal.GetHRForExceptionWinRT(hrExcep);
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int SetValue__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_instance, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_value)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Markup.IXamlMember>(
									__this, 
									7
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__object__(
									__this, 
									unsafe_instance, 
									unsafe_value, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Markup_IXamlMember__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetIIDs")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(16, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetRuntimeClassName")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(20, typeof(global::System.Runtime.InteropServices.__vtable_IInspectable), "GetTrustLevel")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(24, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_IsAttachable__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(28, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_IsDependencyProperty__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(32, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_IsReadOnly__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(36, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_Name__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(40, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_TargetType__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(44, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "get_Type__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(48, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "GetValue__STUB")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(52, typeof(global::Windows.UI.Xaml.Markup.IXamlMember__Impl.Vtbl), "SetValue__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Markup_IXamlMember__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
						0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Markup.XmlnsDefinition
	public unsafe static class XmlnsDefinition__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static int Marshal__SafeToUnsafe(
					ref global::Windows.UI.Xaml.Markup.XmlnsDefinition safeSource, 
					out global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType unsafeDest)
		{
			// [fwd] [in] [optional] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING safeSource
			unsafeDest.XmlNamespace = global::System.Runtime.InteropServices.McgMarshal.StringToHStringForField(safeSource.XmlNamespace);
			// [fwd] [in] [optional] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING safeSource
			unsafeDest.Namespace = global::System.Runtime.InteropServices.McgMarshal.StringToHStringForField(safeSource.Namespace);
			return 0;
		}

		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static int Marshal__UnsafeToSafe(
					ref global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType unsafeSource, 
					out global::Windows.UI.Xaml.Markup.XmlnsDefinition safeDest)
		{
			// [rev] [in] [optional] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING safeDest
			safeDest.XmlNamespace = global::System.Runtime.InteropServices.McgMarshal.HStringToString(unsafeSource.XmlNamespace);
			// [rev] [in] [optional] [Mcg.CodeGen.HSTRINGMarshaller] string__System.Runtime.InteropServices.HSTRING safeDest
			safeDest.Namespace = global::System.Runtime.InteropServices.McgMarshal.HStringToString(unsafeSource.Namespace);
			return 0;
		}

		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Cleanup__Unsafe(ref global::Windows.UI.Xaml.Markup.XmlnsDefinition__Impl.UnsafeType unsafeStruct)
		{
			global::System.Runtime.InteropServices.McgMarshal.FreeHString(unsafeStruct.XmlNamespace.handle);
			global::System.Runtime.InteropServices.McgMarshal.FreeHString(unsafeStruct.Namespace.handle);
		}

		public unsafe struct UnsafeType
		{
			public global::System.Runtime.InteropServices.HSTRING XmlNamespace;
			public global::System.Runtime.InteropServices.HSTRING Namespace;
		}
	}
}

namespace Windows.UI.Xaml.Media
{
	// Windows.UI.Xaml.Media.IGeneralTransform
	public unsafe static class IGeneralTransform__Impl
	{
		// v-table for 'Windows.UI.Xaml.Media.IGeneralTransform'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IGeneralTransform))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Media.IGeneralTransformOverrides
	public unsafe static class IGeneralTransformOverrides__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Media.IGeneralTransformOverrides'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.GeneralTransform get_InverseCore(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.GeneralTransform __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Media.IGeneralTransformOverrides, global::Windows.UI.Xaml.Media.GeneralTransform>(
									__this, 
									global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.Vtbl.idx_get_InverseCore
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			// Signature, Windows.UI.Xaml.Media.IGeneralTransformOverrides.TryTransformCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, [fwd] [out] [managedbyref] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Point__Windows_Foundation__Point, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.CBoolMarshaller] bool__bool, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static bool TryTransformCore(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Point inPoint, 
						out global::Windows.Foundation.Point outPoint)
			{
				// Setup
				global::Windows.Foundation.Point unsafe_outPoint;
				bool returnValue__retval;
				sbyte unsafe_returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Media.IGeneralTransformOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.Vtbl.idx_TryTransformCore, 
									inPoint, 
									&(unsafe_outPoint), 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval != 0;
				outPoint = unsafe_outPoint;
				// Return
				return returnValue__retval;
			}

			// Signature, Windows.UI.Xaml.Media.IGeneralTransformOverrides.TransformBoundsCore, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Rect__Windows_Foundation__Rect, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] Windows_Foundation_Rect__Windows_Foundation__Rect, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.Foundation.Rect TransformBoundsCore(
						global::System.__ComObject __this, 
						global::Windows.Foundation.Rect rect)
			{
				// Setup
				global::Windows.Foundation.Rect unsafe_returnValue__retval;
				global::Windows.Foundation.Rect returnValue__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Media.IGeneralTransformOverrides).TypeHandle, 
									global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.Vtbl.idx_TransformBoundsCore, 
									rect, 
									&(unsafe_returnValue__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				returnValue__retval = unsafe_returnValue__retval;
				// Return
				return returnValue__retval;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Media.IGeneralTransformOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IGeneralTransformOverrides))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Media.IGeneralTransformOverrides
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Media.IGeneralTransformOverrides.InverseCore")]
			global::Windows.UI.Xaml.Media.GeneralTransform global::Windows.UI.Xaml.Media.IGeneralTransformOverrides.get_InverseCore()
			{
				global::Windows.UI.Xaml.Media.GeneralTransform __retVal = global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.StubClass.get_InverseCore(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			bool global::Windows.UI.Xaml.Media.IGeneralTransformOverrides.TryTransformCore(
						global::Windows.Foundation.Point inPoint, 
						out global::Windows.Foundation.Point outPoint)
			{
				bool __retVal = global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.StubClass.TryTransformCore(
									this, 
									inPoint, 
									out outPoint
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			global::Windows.Foundation.Rect global::Windows.UI.Xaml.Media.IGeneralTransformOverrides.TransformBoundsCore(global::Windows.Foundation.Rect rect)
			{
				global::Windows.Foundation.Rect __retVal = global::Windows.UI.Xaml.Media.IGeneralTransformOverrides__Impl.StubClass.TransformBoundsCore(
									this, 
									rect
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Media.IGeneralTransformOverrides'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IGeneralTransformOverrides))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_InverseCore = 6;
			internal const int idx_TryTransformCore = 7;
			internal const int idx_TransformBoundsCore = 8;
		}
	}

	// Windows.UI.Xaml.Media.ITransform
	public unsafe static class ITransform__Impl
	{
		// v-table for 'Windows.UI.Xaml.Media.ITransform'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.ITransform))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Media.IFontFamily
	public unsafe static class IFontFamily__Impl
	{
		// v-table for 'Windows.UI.Xaml.Media.IFontFamily'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IFontFamily))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Media.IBrush
	public unsafe static class IBrush__Impl
	{
		// v-table for 'Windows.UI.Xaml.Media.IBrush'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IBrush))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Media.ICompositeTransform
	public unsafe static class ICompositeTransform__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Media.ICompositeTransform'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static double get_Rotation(global::System.__ComObject __this)
			{
				double __ret = global::McgInterop.ForwardComSharedStubs.Func_double__<global::Windows.UI.Xaml.Media.ICompositeTransform>(
									__this, 
									global::Windows.UI.Xaml.Media.ICompositeTransform__Impl.Vtbl.idx_get_Rotation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Rotation(
						global::System.__ComObject __this, 
						double value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_double__<global::Windows.UI.Xaml.Media.ICompositeTransform>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Media.ICompositeTransform__Impl.Vtbl.idx_put_Rotation
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Media.ICompositeTransform'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.ICompositeTransform))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Media.ICompositeTransform
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Media.ICompositeTransform.Rotation")]
			double global::Windows.UI.Xaml.Media.ICompositeTransform.get_Rotation()
			{
				double __retVal = global::Windows.UI.Xaml.Media.ICompositeTransform__Impl.StubClass.get_Rotation(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Media.ICompositeTransform.Rotation")]
			void global::Windows.UI.Xaml.Media.ICompositeTransform.put_Rotation(double value)
			{
				global::Windows.UI.Xaml.Media.ICompositeTransform__Impl.StubClass.put_Rotation(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Media.ICompositeTransform'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.ICompositeTransform))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Rotation = 18;
			internal const int idx_put_Rotation = 19;
		}
	}

	// Windows.UI.Xaml.Media.ITileBrush
	public unsafe static class ITileBrush__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Media.ITileBrush'
		public static partial class StubClass
		{
			// Signature, Windows.UI.Xaml.Media.ITileBrush.get_Stretch, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.EnumMarshaller] Windows_UI_Xaml_Media_Stretch__Windows_UI_Xaml_Media__Stretch, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.Stretch get_Stretch(global::System.__ComObject __this)
			{
				// Setup
				global::Windows.UI.Xaml.Media.Stretch unsafe_value__retval;
				global::Windows.UI.Xaml.Media.Stretch value__retval;
				int unsafe___return__;
				// Marshalling
				// Call to native method
				unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
									__this, 
									typeof(global::Windows.UI.Xaml.Media.ITileBrush).TypeHandle, 
									global::Windows.UI.Xaml.Media.ITileBrush__Impl.Vtbl.idx_get_Stretch, 
									&(unsafe_value__retval)
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				value__retval = unsafe_value__retval;
				// Return
				return value__retval;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_Stretch(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.Stretch value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_int<global::Windows.UI.Xaml.Media.ITileBrush>(
									__this, 
									((int)value), 
									global::Windows.UI.Xaml.Media.ITileBrush__Impl.Vtbl.idx_put_Stretch
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Media.ITileBrush'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.ITileBrush))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Media.ITileBrush
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Media.ITileBrush.Stretch")]
			global::Windows.UI.Xaml.Media.Stretch global::Windows.UI.Xaml.Media.ITileBrush.get_Stretch()
			{
				global::Windows.UI.Xaml.Media.Stretch __retVal = global::Windows.UI.Xaml.Media.ITileBrush__Impl.StubClass.get_Stretch(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Media.ITileBrush.Stretch")]
			void global::Windows.UI.Xaml.Media.ITileBrush.put_Stretch(global::Windows.UI.Xaml.Media.Stretch value)
			{
				global::Windows.UI.Xaml.Media.ITileBrush__Impl.StubClass.put_Stretch(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Media.ITileBrush'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.ITileBrush))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_Stretch = 10;
			internal const int idx_put_Stretch = 11;
		}
	}

	// Windows.UI.Xaml.Media.IImageSource
	public unsafe static class IImageSource__Impl
	{
		// v-table for 'Windows.UI.Xaml.Media.IImageSource'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IImageSource))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Media.IImageBrush
	public unsafe static class IImageBrush__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Media.IImageBrush'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::Windows.UI.Xaml.Media.ImageSource get_ImageSource(global::System.__ComObject __this)
			{
				global::Windows.UI.Xaml.Media.ImageSource __ret = global::McgInterop.ForwardComSharedStubs.Func_TResult__<global::Windows.UI.Xaml.Media.IImageBrush, global::Windows.UI.Xaml.Media.ImageSource>(
									__this, 
									global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_get_ImageSource
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void put_ImageSource(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.Media.ImageSource value)
			{
				global::McgInterop.ForwardComSharedStubs.Proc_TArg0__<global::Windows.UI.Xaml.Media.IImageBrush, global::Windows.UI.Xaml.Media.ImageSource>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_put_ImageSource
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			// Signature, Windows.UI.Xaml.Media.IImageBrush.add_ImageFailed, [fwd] [return] [Mcg.CodeGen.ComHRESULTReturnMarshaller] void__int, [fwd] [in] [Mcg.CodeGen.WinRTDelegateMarshaller] Windows_UI_Xaml_ExceptionRoutedEventHandler__Windows_UI_Xaml__ExceptionRoutedEventHandler *, [fwd] [out] [retval] [nativebyref] [Mcg.CodeGen.BlittableValueMarshaller] System_Runtime_InteropServices_WindowsRuntime_EventRegistrationToken__Windows_Foundation__EventRegistrationToken, 
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ImageFailed(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.ExceptionRoutedEventHandler value)
			{
				// Setup
				global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl** unsafe_value = default(global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl**);
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken unsafe_token__retval;
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token__retval;
				int unsafe___return__;
				try
				{
					// Marshalling
					unsafe_value = (global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Vtbl**)global::System.Runtime.InteropServices.McgModuleManager.DelegateToComInterface(
										value, 
										typeof(global::Windows.UI.Xaml.ExceptionRoutedEventHandler).TypeHandle, 
										global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget98>(global::Windows.UI.Xaml.ExceptionRoutedEventHandler__Impl.Invoke)
									);
					// Call to native method
					unsafe___return__ = global::McgInterop.ComCallHelpers.ComCall__HRESULT(
										__this, 
										typeof(global::Windows.UI.Xaml.Media.IImageBrush).TypeHandle, 
										global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_add_ImageFailed, 
										unsafe_value, 
										&(unsafe_token__retval)
									);
					global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
					token__retval = unsafe_token__retval;
					// Return
					return token__retval;
				}
				finally
				{
					// Cleanup
					global::System.Runtime.InteropServices.McgMarshal.ComSafeRelease(new global::System.IntPtr(((void*)unsafe_value)));
				}
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ImageFailed(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Media.IImageBrush>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_remove_ImageFailed
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken add_ImageOpened(
						global::System.__ComObject __this, 
						global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __ret = global::McgInterop.ForwardComSharedStubs.Func_UI_Xaml_RoutedEventHandler___WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Media.IImageBrush>(
									__this, 
									value, 
									global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_add_ImageOpened
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static void remove_ImageOpened(
						global::System.__ComObject __this, 
						global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::McgInterop.ForwardComSharedStubs.Proc__WindowsRuntime_EventRegistrationToken__<global::Windows.UI.Xaml.Media.IImageBrush>(
									__this, 
									token, 
									global::Windows.UI.Xaml.Media.IImageBrush__Impl.Vtbl.idx_remove_ImageOpened
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Media.IImageBrush'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IImageBrush))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Media.IImageBrush
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Media.IImageBrush.ImageSource")]
			global::Windows.UI.Xaml.Media.ImageSource global::Windows.UI.Xaml.Media.IImageBrush.get_ImageSource()
			{
				global::Windows.UI.Xaml.Media.ImageSource __retVal = global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.get_ImageSource(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertySet, "Windows.UI.Xaml.Media.IImageBrush.ImageSource")]
			void global::Windows.UI.Xaml.Media.IImageBrush.put_ImageSource(global::Windows.UI.Xaml.Media.ImageSource value)
			{
				global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.put_ImageSource(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Media.IImageBrush.ImageFailed")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Media.IImageBrush.add_ImageFailed(global::Windows.UI.Xaml.ExceptionRoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.add_ImageFailed(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Media.IImageBrush.ImageFailed")]
			void global::Windows.UI.Xaml.Media.IImageBrush.remove_ImageFailed(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.remove_ImageFailed(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventAdd, "Windows.UI.Xaml.Media.IImageBrush.ImageOpened")]
			global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken global::Windows.UI.Xaml.Media.IImageBrush.add_ImageOpened(global::Windows.UI.Xaml.RoutedEventHandler value)
			{
				global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken __retVal = global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.add_ImageOpened(
									this, 
									value
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}

			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.EventRemove, "Windows.UI.Xaml.Media.IImageBrush.ImageOpened")]
			void global::Windows.UI.Xaml.Media.IImageBrush.remove_ImageOpened(global::System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken token)
			{
				global::Windows.UI.Xaml.Media.IImageBrush__Impl.StubClass.remove_ImageOpened(
									this, 
									token
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
			}
		}

		// v-table for 'Windows.UI.Xaml.Media.IImageBrush'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Media.IImageBrush))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_ImageSource = 6;
			internal const int idx_put_ImageSource = 7;
			internal const int idx_add_ImageFailed = 8;
			internal const int idx_remove_ImageFailed = 9;
			internal const int idx_add_ImageOpened = 10;
			internal const int idx_remove_ImageOpened = 11;
		}
	}
}

namespace Windows.UI.Xaml.Navigation
{
	// Windows.UI.Xaml.Navigation.INavigationEventArgs
	public unsafe static class INavigationEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Navigation.INavigationEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigationEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Navigation.INavigationEventArgs2
	public unsafe static class INavigationEventArgs2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Navigation.INavigationEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigationEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs
	public unsafe static class INavigatingCancelEventArgs__Impl
	{
		// v-table for 'Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs2
	public unsafe static class INavigatingCancelEventArgs2__Impl
	{
		// v-table for 'Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs2'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs2))]
		public unsafe partial struct Vtbl
		{
		}
	}

	// Windows.UI.Xaml.Navigation.INavigationFailedEventArgs
	public unsafe static class INavigationFailedEventArgs__Impl
	{
		// StubClass for 'Windows.UI.Xaml.Navigation.INavigationFailedEventArgs'
		public static partial class StubClass
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			public static global::System.Type get_SourcePageType(global::System.__ComObject __this)
			{
				global::System.Type __ret = global::McgInterop.ForwardComSharedStubs.Func_Type__<global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs>(
									__this, 
									global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs__Impl.Vtbl.idx_get_SourcePageType
								);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}
		}

		// DispatchClass for 'Windows.UI.Xaml.Navigation.INavigationFailedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs))]
		public abstract partial class DispatchClass : global::System.__ComObject, global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs
		{
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.McgAccessor(global::System.Runtime.InteropServices.McgAccessorKind.PropertyGet, "Windows.UI.Xaml.Navigation.INavigationFailedEventArgs.SourcePageType")]
			global::System.Type global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs.get_SourcePageType()
			{
				global::System.Type __retVal = global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs__Impl.StubClass.get_SourcePageType(this);
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __retVal;
			}
		}

		// v-table for 'Windows.UI.Xaml.Navigation.INavigationFailedEventArgs'
		[global::System.Runtime.CompilerServices.DependencyReductionConditionallyDependent(typeof(global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs))]
		public unsafe partial struct Vtbl
		{
			internal const int idx_get_SourcePageType = 9;
		}
	}

	// Windows.UI.Xaml.Navigation.NavigatedEventHandler
	public unsafe static class NavigatedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigatedEventHandler, global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Navigation.NavigatedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Navigation__NavigatedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Navigation__NavigatedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Navigation_NavigatedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Navigation_NavigatedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Navigation__NavigatedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget128>(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Navigation.INavigationEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Navigation.NavigatedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Navigation_NavigatedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Navigation.NavigatedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Navigation_NavigatedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler
	public unsafe static class NavigatingCancelEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler, global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Navigation__NavigatingCancelEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Navigation__NavigatingCancelEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl.Windows_UI_Xaml_Navigation_NavigatingCancelEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Navigation_NavigatingCancelEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Navigation__NavigatingCancelEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget129>(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Navigation_NavigatingCancelEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Navigation_NavigatingCancelEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Navigation.NavigationFailedEventHandler
	public unsafe static class NavigationFailedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler, global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Navigation.NavigationFailedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Navigation__NavigationFailedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Navigation__NavigationFailedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Navigation_NavigationFailedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Navigation_NavigationFailedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Navigation__NavigationFailedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget130>(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Navigation.INavigationFailedEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigationFailedEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Navigation_NavigationFailedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Navigation.NavigationFailedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Navigation_NavigationFailedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}

	// Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler
	public unsafe static class NavigationStoppedEventHandler__Impl
	{
		[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
		public static void Invoke(
					this global::System.__ComObject __this, 
					object sender, 
					global::Windows.UI.Xaml.Navigation.NavigationEventArgs e)
		{
			global::McgInterop.ForwardComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler, global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
								__this, 
								sender, 
								e, 
								global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl.idx_Invoke
							);
			global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
		}

		// v-table for 'Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler'
		[global::System.Runtime.InteropServices.McgRootsType(typeof(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler))]
		public unsafe partial struct Vtbl
		{
			global::System.IntPtr pfnQueryInterface;
			global::System.IntPtr pfnAddRef;
			global::System.IntPtr pfnRelease;
			// Windows_UI_Xaml_Navigation__NavigationStoppedEventHandler
			global::System.IntPtr pfnInvoke_Windows_UI_Xaml_Navigation__NavigationStoppedEventHandler;
			internal const int idx_Invoke = 3;
			[global::System.Runtime.CompilerServices.InitDataBlob(typeof(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl.Windows_UI_Xaml_Navigation_NavigationStoppedEventHandler__Impl_Vtbl_McgRvaContainer), "RVA_Windows_UI_Xaml_Navigation_NavigationStoppedEventHandler__Impl_Vtbl_s_theCcwVtable")]
			public static global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl s_theCcwVtable
			#if false
			 = new global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl() {
				pfnQueryInterface = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfQueryInterface>(System.Runtime.InteropServices.__vtable_IUnknown.QueryInterface),
				pfnAddRef = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfAddRef>(System.Runtime.InteropServices.__vtable_IUnknown.AddRef),
				pfnRelease = global::McgInterop.Intrinsics.AddrOf<global::System.Runtime.InteropServices.AddrOfRelease>(System.Runtime.InteropServices.__vtable_IUnknown.Release),
				pfnInvoke_Windows_UI_Xaml_Navigation__NavigationStoppedEventHandler = global::McgInterop.Intrinsics.AddrOf<global::McgInterop.AddrOfIntrinsics.AddrOfTarget128>(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl.Invoke__STUB),
			}
			#endif
			;
			public static global::System.IntPtr pNativeVtable;
			[global::System.Runtime.InteropServices.McgGeneratedMarshallingCode]
			[global::System.Runtime.InteropServices.NativeCallable]
			static int Invoke__STUB(
						global::System.IntPtr pComThis, 
						global::System.Runtime.InteropServices.__vtable_IInspectable* unsafe_sender, 
						global::Windows.UI.Xaml.Navigation.INavigationEventArgs__Impl.Vtbl** unsafe_e)
			{
				object __this = global::System.Runtime.InteropServices.McgMarshal.ThisPointerToTargetObject(pComThis);
				global::System.IntPtr __methodPtr = global::McgInterop.Intrinsics.VirtualAddrOf<global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler>(
									__this, 
									0
								);
				int __ret = ((int)global::McgInterop.ReverseComSharedStubs.Proc_object__TArg0__<global::Windows.UI.Xaml.Navigation.NavigationEventArgs>(
									__this, 
									unsafe_sender, 
									unsafe_e, 
									__methodPtr
								));
				global::System.Runtime.InteropServices.DebugAnnotations.PreviousCallContainsUserCode();
				return __ret;
			}

			private static class Windows_UI_Xaml_Navigation_NavigationStoppedEventHandler__Impl_Vtbl_McgRvaContainer
			{
				[global::System.Runtime.CompilerServices.MethodAddrFixup(0, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "QueryInterface")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(4, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "AddRef")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(8, typeof(global::System.Runtime.InteropServices.__vtable_IUnknown), "Release")]
				[global::System.Runtime.CompilerServices.MethodAddrFixup(12, typeof(global::Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler__Impl.Vtbl), "Invoke__STUB")]
				[global::System.Runtime.CompilerServices.NonArray]
				static readonly byte[] RVA_Windows_UI_Xaml_Navigation_NavigationStoppedEventHandler__Impl_Vtbl_s_theCcwVtable = new byte[] {
						0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
			}
		}
	}
}


// Interop_mincore_CPINFOEXW__System_Text_Encoding_CodePages
public unsafe static class Interop_mincore_CPINFOEXW__System_Text_Encoding_CodePages__Impl
{
}

// Interop_mincore_CPINFOEXW__DefaultChar_e__FixedBuffer__System_Text_Encoding_CodePages
public unsafe static class Interop_mincore_CPINFOEXW__DefaultChar_e__FixedBuffer__System_Text_Encoding_CodePages__Impl
{
}

// Interop_mincore_CPINFOEXW__LeadByte_e__FixedBuffer__System_Text_Encoding_CodePages
public unsafe static class Interop_mincore_CPINFOEXW__LeadByte_e__FixedBuffer__System_Text_Encoding_CodePages__Impl
{
}

// Interop_mincore_CPINFOEXW__CodePageName_e__FixedBuffer__System_Text_Encoding_CodePages
public unsafe static class Interop_mincore_CPINFOEXW__CodePageName_e__FixedBuffer__System_Text_Encoding_CodePages__Impl
{
}
