public static IObservable<System.Reactive.Unit> AddIdentity(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.Security.Claims.ClaimsIdentity> identity)
 {
     return ObservableExt.ZipExecute(ClaimsPrincipalValue, identity,
         (ClaimsPrincipalValueLambda, identityLambda) => ClaimsPrincipalValueLambda.AddIdentity(identityLambda));
 }

 public static IObservable<System.Security.IPermission> AddPermission(
     this IObservable<System.Security.PermissionSet> PermissionSetValue,
     IObservable<System.Security.IPermission> perm)
 {
     return Observable.Zip(PermissionSetValue, perm,
         (PermissionSetValueLambda, permLambda) => PermissionSetValueLambda.AddPermission(permLambda));
 }

 public static IObservable<System.Reactive.Unit> FromXml(
     this IObservable<System.Security.PermissionSet> PermissionSetValue,
     IObservable<System.Security.SecurityElement> et)
 {
     return ObservableExt.ZipExecute(PermissionSetValue, et,
         (PermissionSetValueLambda, etLambda) => PermissionSetValueLambda.FromXml(etLambda));
 }

 public static IObservable<System.Reactive.Unit> FromXml(
     this IObservable<System.Security.Policy.GacMembershipCondition> GacMembershipConditionValue,
     IObservable<System.Security.SecurityElement> e)
 {
     return ObservableExt.ZipExecute(GacMembershipConditionValue, e,
         (GacMembershipConditionValueLambda, eLambda) => GacMembershipConditionValueLambda.FromXml(eLambda));
 }

 public static IObservable<System.Reactive.Unit> EndInvoke(
     this IObservable<System.Threading.SendOrPostCallback> SendOrPostCallbackValue,
     IObservable<System.IAsyncResult> result)
 {
     return ObservableExt.ZipExecute(SendOrPostCallbackValue, result,
         (SendOrPostCallbackValueLambda, resultLambda) => SendOrPostCallbackValueLambda.EndInvoke(resultLambda));
 }

 public static IObservable<int> Read(this IObservable<System.IO.StringReader> StringReaderValue,
     IObservable<System.Char[]> buffer, IObservable<System.Int32> index, IObservable<System.Int32> count)
 {
     return Observable.Zip(StringReaderValue, buffer, index, count,
         (StringReaderValueLambda, bufferLambda, indexLambda, countLambda) =>
             StringReaderValueLambda.Read(bufferLambda, indexLambda, countLambda));
 }

 public static IObservable<System.Reactive.Unit> set_Name(
     this IObservable<System.Diagnostics.Tracing.EventDataAttribute> EventDataAttributeValue,
     IObservable<System.String> value)
 {
     return ObservableExt.ZipExecute(EventDataAttributeValue, value,
         (EventDataAttributeValueLambda, valueLambda) => EventDataAttributeValueLambda.Name = valueLambda);
 }

 public static IObservable<System.Reactive.Unit> set_Value(
     this IObservable<System.Runtime.Remoting.Metadata.W3cXsd2001.SoapAnyUri> SoapAnyUriValue,
     IObservable<System.String> value)
 {
     return ObservableExt.ZipExecute(SoapAnyUriValue, value,
         (SoapAnyUriValueLambda, valueLambda) => SoapAnyUriValueLambda.Value = valueLambda);
 }

 public static IObservable<System.Reactive.Unit> Write(this IObservable<System.IO.TextWriter> TextWriterValue,
     IObservable<System.Char[]> buffer, IObservable<System.Int32> index, IObservable<System.Int32> count)
 {
     return ObservableExt.ZipExecute(TextWriterValue, buffer, index, count,
         (TextWriterValueLambda, bufferLambda, indexLambda, countLambda) =>
             TextWriterValueLambda.Write(bufferLambda, indexLambda, countLambda));
 }

 public static IObservable<System.Boolean> HasClaim(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.Predicate<System.Security.Claims.Claim>> match)
 {
     return Observable.Zip(ClaimsPrincipalValue, match,
         (ClaimsPrincipalValueLambda, matchLambda) => ClaimsPrincipalValueLambda.HasClaim(matchLambda));
 }

 public static IObservable<System.Int32> Skip(
     this IObservable<System.Runtime.InteropServices.UCOMIEnumString> UCOMIEnumStringValue,
     IObservable<System.Int32> celt)
 {
     return Observable.Zip(UCOMIEnumStringValue, celt,
         (UCOMIEnumStringValueLambda, celtLambda) => UCOMIEnumStringValueLambda.Skip(celtLambda));
 }

 public static IObservable<System.Security.Claims.Claim> FindFirst(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.String> type)
 {
     return Observable.Zip(ClaimsPrincipalValue, type,
         (ClaimsPrincipalValueLambda, typeLambda) => ClaimsPrincipalValueLambda.FindFirst(typeLambda));
 }

 public static IObservable<System.Collections.Generic.IEnumerable<System.Security.Claims.Claim>> FindAll(
     this IObservable<System.Security.Claims.ClaimsPrincipal> ClaimsPrincipalValue,
     IObservable<System.String> type)
 {
     return Observable.Zip(ClaimsPrincipalValue, type,
         (ClaimsPrincipalValueLambda, typeLambda) => ClaimsPrincipalValueLambda.FindAll(typeLambda));
 }

        public OpenGLInputObservable(GameWindow window)
        {
            gameWindow = window;

            IObservable<IInput> downEvents =
                from evt in Observable.FromEventPattern<KeyboardKeyEventArgs>(window, "KeyDown")
                let keyInput = GLKeyInput.FromArgs(evt.EventArgs, false)
                where keyInput != null
                select keyInput;

            IObservable<IInput> upEvents =
                from evt in Observable.FromEventPattern<KeyboardKeyEventArgs>(window, "KeyUp")
                let keyInput = GLKeyInput.FromArgs(evt.EventArgs, true)
                where keyInput != null
                select keyInput;

            IObservable<IInput> mouseMoveEvents =
                from evt in Observable.FromEventPattern<MouseMoveEventArgs>(window, "MouseMove")
                from mouseInput in GLMouseInput.FromArgs(evt.EventArgs, gameWindow.Width, gameWindow.Height)
                select mouseInput;

            IObservable<IInput> mouseDownEvents =
                from evt in Observable.FromEventPattern<MouseButtonEventArgs>(window, "MouseDown")
                select GLMouseClickInput.FromArgs(evt.EventArgs, false);

            IObservable<IInput> mouseUpEvents =
                from evt in Observable.FromEventPattern<MouseButtonEventArgs>(window, "MouseUp")
                select GLMouseClickInput.FromArgs(evt.EventArgs, true);

            InputEvents = downEvents.Merge(upEvents).Merge(mouseMoveEvents).Merge(mouseDownEvents).Merge(mouseUpEvents);

            window.MouseMove += (sender, e) => Cursor.Position = new Point(window.Width / 2, window.Height / 2); // keep mouse centered (bc fps)
        }

 public static IObservable<System.Reactive.Unit> SetAt(
     this IObservable<System.Security.SecureString> SecureStringValue, IObservable<System.Int32> index,
     IObservable<System.Char> c)
 {
     return ObservableExt.ZipExecute(SecureStringValue, index, c,
         (SecureStringValueLambda, indexLambda, cLambda) => SecureStringValueLambda.SetAt(indexLambda, cLambda));
 }

 public static IObservable<System.Reactive.Unit> set_Order(
     this IObservable<System.Runtime.Remoting.Metadata.SoapFieldAttribute> SoapFieldAttributeValue,
     IObservable<System.Int32> value)
 {
     return ObservableExt.ZipExecute(SoapFieldAttributeValue, value,
         (SoapFieldAttributeValueLambda, valueLambda) => SoapFieldAttributeValueLambda.Order = valueLambda);
 }

 public static IObservable<System.Reactive.Unit> Load(
     this IObservable<System.Runtime.InteropServices.UCOMIMoniker> UCOMIMonikerValue,
     IObservable<System.Runtime.InteropServices.UCOMIStream> pStm)
 {
     return ObservableExt.ZipExecute(UCOMIMonikerValue, pStm,
         (UCOMIMonikerValueLambda, pStmLambda) => UCOMIMonikerValueLambda.Load(pStmLambda));
 }

 public static IObservable<System.Byte[]> GetDeploymentManifestBytes(
     IObservable<System.ActivationContext> appInfo)
 {
     return Observable.Select(appInfo,
         (appInfoLambda) =>
             System.Deployment.Internal.InternalActivationContextHelper.GetDeploymentManifestBytes(appInfoLambda));
 }

 public static IObservable<System.Reactive.Unit> SetExceptions(
     this IObservable<System.Reflection.Emit.DynamicILInfo> DynamicILInfoValue,
     IObservable<System.Byte[]> exceptions)
 {
     return ObservableExt.ZipExecute(DynamicILInfoValue, exceptions,
         (DynamicILInfoValueLambda, exceptionsLambda) => DynamicILInfoValueLambda.SetExceptions(exceptionsLambda));
 }

 public static IObservable<System.Boolean> Equals(
     this IObservable<System.Security.Policy.GacMembershipCondition> GacMembershipConditionValue,
     IObservable<System.Object> o)
 {
     return Observable.Zip(GacMembershipConditionValue, o,
         (GacMembershipConditionValueLambda, oLambda) => GacMembershipConditionValueLambda.Equals(oLambda));
 }