From 77a6bf8693dfcbdcdb515a14348b5c7a219e0a6a Mon Sep 17 00:00:00 2001
From: Jonathan Pryor <jonpryor@vt.edu>
Date: Fri, 4 Dec 2015 15:18:44 -0500
Subject: [PATCH] [Java.Interop] Replace JniMarshalInfo with JniValueMarshaler.

Context: https://github.com/xamarin/Java.Interop/issues/2
Context: https://github.com/xamarin/Java.Interop/issues/8

From Issue #8:

> I don't like JniMarshalInfo; it's too convoluted, makes the
> simple cases hard.

What do we mean by "hard"?  We mean that it's use is error prone,
because what you need to do depends on the values of the
JniMarshalInfo members, which is best characterized by what
JniArgumentMarshalInfo had to do to create a JNI Local refererence:

	JniObjectReference lref;

	var marshaler = JniRuntime.CurrentRuntime.ValueManager.GetJniMarshalInfoForType (type);
	if (info.CreateMarshalCollection != null) {
		var obj = info.CreateMarshalCollection (value);
		lref    = obj.PeerReference;
	} else if (info.CreateLocalRef != null) {
		lref    = info.CreateLocalRef (value);
	} else
		throw new NotSupportedException ("Don't know how to get a JNI Local Reference!");

	// can now use `lref`...

Need to pass as a method argument? Similar-yet-different.  Then
there's the cleanup code!

The eventual intention is for tools/jnimarshalmethod-gen to
post-process assemblies and generate Java > Managed marshal methods
for all resolvable methods, and do this "dynamically" based on the
actual types involved.  This will allow "fixing" binding assemblies
when involved types change, because binding assemblies won't be as
"static" as they are in Xamarin.Android.  (Which is why Issue #8
mentions using Expressions for the marshaling.)

However, before we can get there we first need a rational marshaling
abstrasction, something that is "pluggable" and readily extensible, so
taht we can e.g. have a custom attribute to control which marshaler to
use on types, parameters, and method return types.  JniMarshalInfo
wasn't that abstraction, and couldn't *be* that abstraction.

To replace JniMarshalInfo, introduce JniValueMarshaler and
JniValueMarshler<T>:

	public abstract partial class JniValueMarshaler {
		public  abstract    object                  CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null);
		public  virtual     JniValueMarshalerState  CreateArgumentState (object value, ParameterAttributes synchronize = 0);
		public  abstract    JniValueMarshalerState  CreateObjectReferenceArgumentState (object value, ParameterAttributes synchronize = 0);
		public  abstract    void                    DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0);
	}

	public abstract partial class JniValueMarshaler<T> : JniValueMarshaler {
		public  abstract    T                       CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null);
		public  virtual     JniValueMarshalerState  CreateGenericArgumentState (T value, ParameterAttributes synchronize = 0);
		public  abstract    JniValueMarshalerState  CreateGenericObjectReferenceArgumentState (T value, ParameterAttributes synchronize = 0);
		public  abstract    void                    DestroyGenericArgumentState (T value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0);

		public override object                  CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null);
		public override JniValueMarshalerState  CreateArgumentState (object value, ParameterAttributes synchronize = 0);
		public override JniValueMarshalerState  CreateObjectReferenceArgumentState (object value, ParameterAttributes synchronize = 0);
		public override void                    DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0);
	}

The intention is that a custom marshaler can be introduced by
inheriting from JniValueMarshaler<T> and overriding three methods.
This also provides a reasonable abstraction, e.g. to create a
JNI Local Reference:

	var state = marshaler.CreateGenericObjectReferenceArgumentState (value);
	// state.ReferenceValue contains a JNI Object Reference
	// use, then cleanup:
	marshaler.DestroyGenericArgumentState (value, ref state);

The methods are as follows:

  * CreateValue, CreateGenericValue:
    Java > Managed marshaler.
    Given a JniObjectReference, marshal the value to a type compatible
    with specified targetType, which should be either null or a class
    assignment compatible to T.

The other methods use a JniValueMarshalerState type:

	public partial struct JniValueMarshalerState {
		public JniArgumentValue         JniArgumentValue {get;}
		public JniObjectReference       ReferenceValue   {get;}
		public IJavaPeerable            PeerableValue    {get;}
	}

The remaining methods of import are:

  * CreateArgumentState(), CreateGenericArgumentState():
    Managed > Java marshaler.
    Used when the intention is to use
    JniValueMarshalerState.JniArgumentValue, which in turn is for use
    with JniEnvironment.*Methods.Call*Method().

  * CreateObjectReferenceArgumentState(),
    CreateGenericObjectReferenceArgumentState():
    Managed > Java marshaler.
    Used when the intention is to use
    JniValueMarshalerState.ReferenceValue.

  * DestroyArgumentState(), DestroyGenericArgumentState(): Generic
    resource cleanup mechanism for use with Create*ArgumentState().

The primary difference between Create*ArgumentState() and
Create*ObjectReferenceArgumentState() is with builtin value types,
e.g. `int`. Create*ArgumentState() will *only* provide a
JniArgumentValue, while JniValueMarshalerState.ReferenceValue will be
null. Create*ObjectReferenceArgumentState(), meanwhile, will "box" the
value type, providing a valid JniValueMarshalerState.ReferenceValue.
For all other types, these methods are identical.

JniValueMarshaler and JniValueMarshalerState together combine to
replace JniMarshalInfo and JniArgumentMarshalInfo, the latter of which
(1) wasn't public, and (2) was "duplicated" between the generic
marshalers and Java.Interop.Dynamic.  JniValueMarshaler thus allows
cleaning up this duplication.

Along with the new JniValueMarshaler abstraction, we provide
implementations for all builtin types, Nullable<T> for builtin types
(which always box), arrays of the builtin types, JavaObjectArray<T>,
IJavaPeerable, and `object`.

The `object` marshaler supersedes the previous
JniMarshal.GetValue<T>() semantics, using JavaProxyObject as needed.

One thing to note is the ParameterAttributes parameters.  This value
is intended to correspond with
System.Reflection.ParameterInfo.Attributes.  jnimarshalmethod-gen can
thus use the actual MethodInfo + ParameterInfo to encode parameter
marshaling direction.  For most types this won't be useful; this is
largely intended for *arrays*, e.g. we could have an `[In] int[]`
parameter which thus avoids the "copy out" behavior Xamarin.Android
currently performs, thus avoiding an extra JNI transition.  Or
vice-versa, have an `[Out] int[]` parameter, which avoids a JNI
transition to copy the managed `int[]` to the Java `int[]`, replacing
it with the copy-out transition.

Partially addressing Issue #2, this also introduces
JniRuntime.JniValueManager.GetValue() and GetValue<T>() methods.
GetObject() is not yet replaced, but will be in a future commit.
Actual implementation will be done alongside introduction of
CreateValue<T>() and cleaning up JniValueMarshaler.Create*Value()
methods to always create values when able, simplifying the logic if
JniValueMarshaler implementations.
---
 .../Java.Interop.Dynamic/DynamicJavaClass.cs  |    36 -
 .../Java.Interop.Dynamic/JavaClassInfo.cs     |    20 +-
 .../Java.Interop.Dynamic/JavaFieldInfo.cs     |    22 +-
 .../Java.Interop.Dynamic/JniMetaObject.cs     |    10 +-
 src/Java.Interop/Java.Interop.csproj          |     3 +-
 src/Java.Interop/Java.Interop/JavaArray.cs    |    66 +-
 .../Java.Interop/JavaObjectArray.cs           |    57 +-
 .../Java.Interop/JavaPrimitiveArrays.cs       |   611 +-
 .../Java.Interop/JavaPrimitiveArrays.tt       |    79 +-
 .../Java.Interop/JniArgumentValue.cs          |    24 +-
 .../Java.Interop/JniBuiltinMarshalers.cs      |   800 +-
 .../Java.Interop/JniBuiltinMarshalers.tt      |   107 +-
 src/Java.Interop/Java.Interop/JniMarshal.cs   |    56 +-
 .../Java.Interop/JniMarshalInfo.cs            |    21 -
 .../JniPeerMembers.JniInstanceMethods.cs      |    38 -
 .../Java.Interop/JniPeerMembers.JniMethods.cs | 14960 +++++++++-------
 .../Java.Interop/JniPeerMembers.JniMethods.tt |    28 +-
 .../JniRuntime.JniValueManager.cs             |   220 +-
 .../Java.Interop/JniStringValueMarshaler.cs   |    29 +
 .../Java.Interop/JniValueMarshaler.cs         |   126 +
 .../Tests/Interop-Tests.projitems             |     1 +
 .../Tests/Java.Interop/JniRuntimeTest.cs      |   117 -
 .../JniValueMarshalerContractTests.cs         |   412 +
 23 files changed, 10905 insertions(+), 6938 deletions(-)
 delete mode 100644 src/Java.Interop/Java.Interop/JniMarshalInfo.cs
 create mode 100644 src/Java.Interop/Java.Interop/JniStringValueMarshaler.cs
 create mode 100644 src/Java.Interop/Java.Interop/JniValueMarshaler.cs
 create mode 100644 src/Java.Interop/Tests/Java.Interop/JniValueMarshalerContractTests.cs

diff --git a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/DynamicJavaClass.cs b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/DynamicJavaClass.cs
index 8e8c9bc92..5d97b974b 100644
--- a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/DynamicJavaClass.cs
+++ b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/DynamicJavaClass.cs
@@ -144,41 +144,5 @@ static JavaModifiers ()
 			}
 		}
 	}
-
-	struct JniArgumentMarshalInfo {
-		JniArgumentValue                jvalue;
-		JniObjectReference              lref;
-		IJavaPeerable                   obj;
-		Action<IJavaPeerable, object>   cleanup;
-
-		internal JniArgumentMarshalInfo (object value, Type valueType)
-		{
-			this        = new JniArgumentMarshalInfo ();
-			var jvm     = JniEnvironment.Runtime;
-			var info    = jvm.ValueManager.GetJniMarshalInfoForType (valueType);
-			if (info.CreateJniArgumentValue != null)
-				jvalue = info.CreateJniArgumentValue (value);
-			else if (info.CreateMarshalCollection != null) {
-				obj     = info.CreateMarshalCollection (value);
-				jvalue  = new JniArgumentValue (obj);
-			} else if (info.CreateLocalRef != null) {
-				lref    = info.CreateLocalRef (value);
-				jvalue  = new JniArgumentValue (lref);
-			} else
-				throw new NotSupportedException ("Don't know how to get a JniArgumentValue for: " + valueType.FullName);
-			cleanup     = info.CleanupMarshalCollection;
-		}
-
-		public JniArgumentValue JniArgumentValue {
-			get {return jvalue;}
-		}
-
-		public  void    Cleanup (object value)
-		{
-			if (cleanup != null && obj != null)
-				cleanup (obj, value);
-			JniObjectReference.Dispose (ref lref);
-		}
-	}
 }
 
diff --git a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaClassInfo.cs b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaClassInfo.cs
index 853ff86f4..ff9c0697d 100644
--- a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaClassInfo.cs
+++ b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaClassInfo.cs
@@ -291,7 +291,8 @@ static bool IsStatic (JniObjectReference member)
 		internal unsafe bool TryInvokeMember (IJavaPeerable self, JavaMethodBase[] overloads, DynamicMetaObject[] args, out object value)
 		{
 			value       = null;
-			var margs   = (List<JniArgumentMarshalInfo>) null;
+			var vms     = (List<JniValueMarshaler>) null;
+			var states  = (JniValueMarshalerState[]) null;
 
 			var jtypes  = GetJniTypes (args);
 			try {
@@ -300,16 +301,21 @@ internal unsafe bool TryInvokeMember (IJavaPeerable self, JavaMethodBase[] overl
 				if (invoke == null)
 					return false;
 
-				margs       = args.Select (arg => new JniArgumentMarshalInfo (arg.Value, arg.LimitType)).ToList ();
-				var jargs   = stackalloc JniArgumentValue [margs.Count];
-				for (int i = 0; i < margs.Count; ++i)
-					jargs [i] = margs [i].JniArgumentValue;
+				var jvm     = JniEnvironment.Runtime;
+				vms         = args.Select (arg => jvm.ValueManager.GetValueMarshaler (arg.LimitType)).ToList ();
+				states      = new JniValueMarshalerState [vms.Count];
+				for (int i = 0; i < vms.Count; ++i) {
+					states [i]  = vms [i].CreateArgumentState (args [i].Value);
+				}
+				var jargs   = stackalloc JniArgumentValue [vms.Count];
+				for (int i = 0; i < states.Length; ++i)
+					jargs [i] = states [i].JniArgumentValue;
 				value       = invoke.Invoke (self, jargs);
 				return true;
 			}
 			finally {
-				for (int i = 0; margs != null && i < margs.Count; ++i) {
-					margs [i].Cleanup (args [i].Value);
+				for (int i = 0; vms != null && i < vms.Count; ++i) {
+					vms [i].DestroyArgumentState (args [i].Value, ref states [i]);
 				}
 				for (int i = 0; i < jtypes.Count; ++i) {
 					if (jtypes [i] != null)
diff --git a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaFieldInfo.cs b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaFieldInfo.cs
index 6916bbb8c..068ee32e4 100644
--- a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaFieldInfo.cs
+++ b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JavaFieldInfo.cs
@@ -137,11 +137,16 @@ void SetStaticValue (object value)
 			case 'D':   members.StaticFields.SetValue (JniSignature, (double) value);   break;
 			case 'L':
 			case '[':
-				var lref = JniMarshal.CreateLocalRef (value);
+				if (value == null) {
+					members.StaticFields.SetValue (JniSignature, new JniObjectReference ());
+					return;
+				}
+				var vm  = JniEnvironment.Runtime.ValueManager.GetValueMarshaler (value.GetType ());
+				var s   = vm.CreateArgumentState (value);
 				try {
-					members.StaticFields.SetValue (JniSignature, lref);
+					members.StaticFields.SetValue (JniSignature, s.ReferenceValue);
 				} finally {
-					JniObjectReference.Dispose (ref lref);
+					vm.DestroyArgumentState (value, ref s, 0);
 				}
 				return;
 			default:
@@ -163,11 +168,16 @@ void SetInstanceValue (IJavaPeerable self, object value)
 			case 'D':   members.InstanceFields.SetValue (JniSignature, self,    (double) value);   break;
 			case 'L':
 			case '[':
-				var lref = JniMarshal.CreateLocalRef (value);
+				if (value == null) {
+					members.InstanceFields.SetValue (JniSignature, self, new JniObjectReference ());
+					return;
+				}
+				var vm  = JniEnvironment.Runtime.ValueManager.GetValueMarshaler (value.GetType ());
+				var s   = vm.CreateArgumentState (value);
 				try {
-					members.InstanceFields.SetValue (JniSignature, self, lref);
+					members.InstanceFields.SetValue (JniSignature, self, s.ReferenceValue);
 				} finally {
-					JniObjectReference.Dispose (ref lref);
+					vm.DestroyArgumentState (value, ref s, 0);
 				}
 				return;
 			default:
diff --git a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JniMetaObject.cs b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JniMetaObject.cs
index 02a2298f2..1ec36f165 100644
--- a/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JniMetaObject.cs
+++ b/src/Java.Interop.Dynamic/Java.Interop.Dynamic/JniMetaObject.cs
@@ -52,12 +52,14 @@ public override DynamicMetaObject BindConvert (ConvertBinder binder)
 				return new DynamicMetaObject (typeE, BindingRestrictions.GetTypeRestriction (typeE, binder.Type), type);
 			}
 
-			var marshalInfo = vm.ValueManager.GetJniMarshalInfoForType (binder.Type);
-			if (marshalInfo.GetValueFromJni == null)
+			object value;
+			try {
+				var r   = ConversionTarget;
+				value   = vm.ValueManager.GetValue (ref r, JniObjectReferenceOptions.Copy, binder.Type);
+			} catch {
 				return binder.FallbackConvert (this);
+			}
 
-			var r       = ConversionTarget;
-			var value   = marshalInfo.GetValueFromJni (ref r, JniObjectReferenceOptions.Copy, binder.Type);
 			var valueE  = Expression.Convert (Expression.Constant (value), binder.Type);
 			return new DynamicMetaObject (valueE, BindingRestrictions.GetTypeRestriction (valueE, binder.Type), value);
 		}
diff --git a/src/Java.Interop/Java.Interop.csproj b/src/Java.Interop/Java.Interop.csproj
index 0faea7a94..bd3aa339e 100644
--- a/src/Java.Interop/Java.Interop.csproj
+++ b/src/Java.Interop/Java.Interop.csproj
@@ -119,14 +119,15 @@
     <Compile Include="Java.Interop\JniLocalReference.cs" />
     <Compile Include="Java.Interop\JniMarshal.cs" />
     <Compile Include="Java.Interop\JniMarshalMethod.cs" />
-    <Compile Include="Java.Interop\JniMarshalInfo.cs" />
     <Compile Include="Java.Interop\JniPeerMembers.JniMethods.cs">
       <DependentUpon>JniPeerMembers.JniMethods.tt</DependentUpon>
     </Compile>
     <Compile Include="Java.Interop\JniReferenceSafeHandle.cs" />
     <Compile Include="Java.Interop\JniRuntime.JniExportedMemberBuilder.cs" />
     <Compile Include="Java.Interop\JniRuntime.JniValueManager.cs" />
+    <Compile Include="Java.Interop\JniStringValueMarshaler.cs" />
     <Compile Include="Java.Interop\JniSystem.cs" />
+    <Compile Include="Java.Interop\JniValueMarshaler.cs" />
     <Compile Include="Java.Interop\JniWeakGlobalReference.cs" />
     <Compile Include="Java.Interop\ManagedPeer.cs" />
   </ItemGroup>
diff --git a/src/Java.Interop/Java.Interop/JavaArray.cs b/src/Java.Interop/Java.Interop/JavaArray.cs
index adf44d768..7b4931c04 100644
--- a/src/Java.Interop/Java.Interop/JavaArray.cs
+++ b/src/Java.Interop/Java.Interop/JavaArray.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Reflection;
 
 namespace Java.Interop
 {
@@ -102,7 +103,7 @@ internal IList<T> ToTargetType (Type targetType, bool dispose)
 		{
 			if (TargetTypeIsCurrentType (targetType))
 				return this;
-			if (targetType == typeof (T[])) {
+			if (targetType == typeof (T[]) || targetType.GetTypeInfo ().IsAssignableFrom (typeof (IList<T>).GetTypeInfo ())) {
 				try {
 					return ToArray ();
 				} finally {
@@ -125,22 +126,7 @@ internal static Exception CreateMarshalNotSupportedException (Type sourceType, T
 						sourceType.FullName, targetType.FullName));
 		}
 
-		internal static JniObjectReference CreateLocalRef<TArray> (object value, Func<IList<T>, TArray> creator)
-			where TArray : JavaArray<T>
-		{
-			if (value == null)
-				return new JniObjectReference ();
-			var array = value as TArray;
-			if (array != null)
-				return array.PeerReference.NewLocalRef ();
-			var items = value as IList<T>;
-			if (items == null)
-				throw CreateMarshalNotSupportedException (value.GetType (), typeof (TArray));
-			using (array = creator (items))
-				return array.PeerReference.NewLocalRef ();
-		}
-
-		internal static IList<T> GetValueFromJni<TArray> (ref JniObjectReference reference, JniObjectReferenceOptions transfer, Type targetType, ArrayCreator<TArray> creator)
+		internal static IList<T> CreateValue<TArray> (ref JniObjectReference reference, JniObjectReferenceOptions transfer, Type targetType, ArrayCreator<TArray> creator)
 			where TArray : JavaArray<T>
 		{
 			var value = JniEnvironment.Runtime.ValueManager.PeekObject (reference);
@@ -153,37 +139,57 @@ internal static IList<T> GetValueFromJni<TArray> (ref JniObjectReference referen
 				.ToTargetType (targetType, dispose: true);
 		}
 
-		internal static IJavaPeerable CreateMarshalCollection<TArray> (object value, Func<IList<T>, TArray> creator)
+		internal    static  JniValueMarshalerState  CreateArgumentState<TArray> (IList<T> value, ParameterAttributes synchronize, Func<IList<T>, bool, TArray> creator)
 			where TArray : JavaArray<T>
 		{
 			if (value == null)
-				return null;
+				return new JniValueMarshalerState ();
 			var v = value as TArray;
-			if (v != null)
-				return v;
+			if (v != null) {
+				return new JniValueMarshalerState (v);
+			}
 			var list = value as IList<T>;
 			if (list == null)
 				throw CreateMarshalNotSupportedException (value.GetType (), typeof (TArray));
-			return creator (list);
+			synchronize = GetCopyDirection (synchronize);
+			var c   = (synchronize & ParameterAttributes.In) == ParameterAttributes.In;
+			var a   = creator (list, c);
+			return new JniValueMarshalerState (a);
 		}
 
-		internal static void CleanupMarshalCollection<TArray> (IJavaPeerable marshalObject, object value)
+		internal static void DestroyArgumentState<TArray> (IList<T> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
 			where TArray : JavaArray<T>
 		{
-			var source = (TArray) marshalObject;
+			var source = (TArray) state.PeerableValue;
 			if (source == null)
 				return;
 
-			var arrayDest = value as T[];
-			var listDest  = value as IList<T>;
-			if (arrayDest != null)
-				source.CopyTo (arrayDest, 0);
-			else if (listDest != null)
-				source.CopyToList (listDest, 0);
+			Debug.WriteLine ("# jonp: JavaArray<{0}>.DestroyArgumentState<{1}>: synchronize={2}", typeof(T).FullName, typeof(TArray).FullName, synchronize);
+			synchronize = GetCopyDirection (synchronize);
+			if ((synchronize & ParameterAttributes.Out) == ParameterAttributes.Out) {
+				var arrayDest = value as T[];
+				var listDest  = value as IList<T>;
+				if (arrayDest != null)
+					source.CopyTo (arrayDest, 0);
+				else if (listDest != null)
+					source.CopyToList (listDest, 0);
+			}
 
 			if (source.forMarshalCollection) {
 				source.Dispose ();
 			}
+
+			state   = new JniValueMarshalerState ();
+		}
+
+		internal static ParameterAttributes GetCopyDirection (ParameterAttributes value)
+		{
+			// If .In or .Out are specified, use as-is.
+			// Otherwise, we should copy both directions.
+			const   ParameterAttributes     inout   = ParameterAttributes.In | ParameterAttributes.Out;
+			if ((value & inout) != 0)
+				return (value & inout);
+			return inout;
 		}
 
 		internal virtual void CopyToList (IList<T> list, int index)
diff --git a/src/Java.Interop/Java.Interop/JavaObjectArray.cs b/src/Java.Interop/Java.Interop/JavaObjectArray.cs
index 13e2049c1..0227ca82c 100644
--- a/src/Java.Interop/Java.Interop/JavaObjectArray.cs
+++ b/src/Java.Interop/Java.Interop/JavaObjectArray.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 
 namespace Java.Interop
 {
@@ -59,14 +60,15 @@ public override T this [int index] {
 		T GetElementAt (int index)
 		{
 			var lref = JniEnvironment.Arrays.GetObjectArrayElement (PeerReference, index);
-			return JniMarshal.GetValue<T> (ref lref, JniObjectReferenceOptions.CopyAndDispose);
+			return JniEnvironment.Runtime.ValueManager.GetValue<T> (ref lref, JniObjectReferenceOptions.CopyAndDispose);
 		}
 
 		void SetElementAt (int index, T value)
 		{
-			var h = JniMarshal.CreateLocalRef (value);
-			JniEnvironment.Arrays.SetObjectArrayElement (PeerReference, index, h);
-			JniObjectReference.Dispose (ref h, JniObjectReferenceOptions.CopyAndDispose);
+			var vm  = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var s   = vm.CreateGenericObjectReferenceArgumentState (value);
+			JniEnvironment.Arrays.SetObjectArrayElement (PeerReference, index, s.ReferenceValue);
+			vm.DestroyGenericArgumentState (value, ref s, 0);
 		}
 
 		public override IEnumerator<T> GetEnumerator ()
@@ -80,11 +82,12 @@ public override IEnumerator<T> GetEnumerator ()
 		public override void Clear ()
 		{
 			int len = Length;
-			var v = JniMarshal.CreateLocalRef (default (T));
+			var vm  = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var s   = vm.CreateArgumentState (default (T));
 			for (int i = 0; i < len; i++) {
-				JniEnvironment.Arrays.SetObjectArrayElement (PeerReference, i, v);
+				JniEnvironment.Arrays.SetObjectArrayElement (PeerReference, i, s.ReferenceValue);
 			}
-			JniObjectReference.Dispose (ref v, JniObjectReferenceOptions.CopyAndDispose);
+			vm.DestroyGenericArgumentState (default (T), ref s, 0);
 		}
 
 		public override int IndexOf (T item)
@@ -132,28 +135,30 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				targetType == typeof (JavaObjectArray<T>);
 		}
 
-		internal static object GetValue (ref JniObjectReference handle, JniObjectReferenceOptions transfer, Type targetType)
-		{
-			return JavaArray<T>.GetValueFromJni (ref handle, transfer, targetType, (ref JniObjectReference h, JniObjectReferenceOptions t) => new JavaObjectArray<T> (ref h, t) {
-				forMarshalCollection    = true,
-			});
-		}
+		internal class ValueMarshaler : JniValueMarshaler<IList<T>> {
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-			return JavaArray<T>.CreateLocalRef (value, list => new JavaObjectArray<T>(list));
-		}
+			public override IList<T> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<T>.CreateValue (ref reference, options, targetType, (ref JniObjectReference h, JniObjectReferenceOptions t) => new JavaObjectArray<T> (ref h, t) {
+					forMarshalCollection    = true,
+				});
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-			return JavaArray<T>.CreateMarshalCollection (value, list => new JavaObjectArray<T> (list) {
-				forMarshalCollection    = true,
-			});
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<T> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<T>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaObjectArray<T> (list)
+						: new JavaObjectArray<T> (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-			JavaArray<T>.CleanupMarshalCollection<JavaObjectArray<T>> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<T> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<T>.DestroyArgumentState<JavaObjectArray<T>> (value, ref state, synchronize);
+			}
 		}
 	}
 }
diff --git a/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.cs b/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.cs
index 2c14d8bb0..e5272e832 100644
--- a/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.cs
+++ b/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.cs
@@ -2,6 +2,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reflection;
 
 namespace Java.Interop {
 
@@ -25,199 +26,39 @@ partial class JniRuntime {
 			new KeyValuePair<Type, JniTypeSignature>(typeof (JavaArray<Double>),           new JniTypeSignature ("D", arrayRank: 1, keyword: true)),
 		};
 
-		static readonly KeyValuePair<Type, JniMarshalInfo>[] JniPrimitiveArrayMarshalers = new []{
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Boolean[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaBooleanArray.GetValueFromJni,
-				CreateLocalRef              = JavaBooleanArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaBooleanArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaBooleanArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Boolean>), new JniMarshalInfo {
-				GetValueFromJni             = JavaBooleanArray.GetValueFromJni,
-				CreateLocalRef              = JavaBooleanArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaBooleanArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaBooleanArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Boolean>), new JniMarshalInfo {
-				GetValueFromJni             = JavaBooleanArray.GetValueFromJni,
-				CreateLocalRef              = JavaBooleanArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaBooleanArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaBooleanArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaBooleanArray), new JniMarshalInfo {
-				GetValueFromJni             = JavaBooleanArray.GetValueFromJni,
-				CreateLocalRef              = JavaBooleanArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaBooleanArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaBooleanArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (SByte[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaSByteArray.GetValueFromJni,
-				CreateLocalRef              = JavaSByteArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSByteArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSByteArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<SByte>), new JniMarshalInfo {
-				GetValueFromJni             = JavaSByteArray.GetValueFromJni,
-				CreateLocalRef              = JavaSByteArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSByteArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSByteArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<SByte>), new JniMarshalInfo {
-				GetValueFromJni             = JavaSByteArray.GetValueFromJni,
-				CreateLocalRef              = JavaSByteArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSByteArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSByteArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaSByteArray), new JniMarshalInfo {
-				GetValueFromJni             = JavaSByteArray.GetValueFromJni,
-				CreateLocalRef              = JavaSByteArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSByteArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSByteArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Char[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaCharArray.GetValueFromJni,
-				CreateLocalRef              = JavaCharArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaCharArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaCharArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Char>), new JniMarshalInfo {
-				GetValueFromJni             = JavaCharArray.GetValueFromJni,
-				CreateLocalRef              = JavaCharArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaCharArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaCharArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Char>), new JniMarshalInfo {
-				GetValueFromJni             = JavaCharArray.GetValueFromJni,
-				CreateLocalRef              = JavaCharArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaCharArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaCharArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaCharArray), new JniMarshalInfo {
-				GetValueFromJni             = JavaCharArray.GetValueFromJni,
-				CreateLocalRef              = JavaCharArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaCharArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaCharArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int16[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt16Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt16Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt16Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt16Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Int16>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt16Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt16Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt16Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt16Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Int16>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt16Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt16Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt16Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt16Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaInt16Array), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt16Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt16Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt16Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt16Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int32[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt32Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt32Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt32Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt32Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Int32>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt32Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt32Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt32Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt32Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Int32>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt32Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt32Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt32Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt32Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaInt32Array), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt32Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt32Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt32Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt32Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int64[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt64Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt64Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt64Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt64Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Int64>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt64Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt64Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt64Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt64Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Int64>), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt64Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt64Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt64Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt64Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaInt64Array), new JniMarshalInfo {
-				GetValueFromJni             = JavaInt64Array.GetValueFromJni,
-				CreateLocalRef              = JavaInt64Array.CreateLocalRef,
-				CreateMarshalCollection     = JavaInt64Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaInt64Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Single[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaSingleArray.GetValueFromJni,
-				CreateLocalRef              = JavaSingleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSingleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSingleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Single>), new JniMarshalInfo {
-				GetValueFromJni             = JavaSingleArray.GetValueFromJni,
-				CreateLocalRef              = JavaSingleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSingleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSingleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Single>), new JniMarshalInfo {
-				GetValueFromJni             = JavaSingleArray.GetValueFromJni,
-				CreateLocalRef              = JavaSingleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSingleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSingleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaSingleArray), new JniMarshalInfo {
-				GetValueFromJni             = JavaSingleArray.GetValueFromJni,
-				CreateLocalRef              = JavaSingleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaSingleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaSingleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Double[]), new JniMarshalInfo {
-				GetValueFromJni             = JavaDoubleArray.GetValueFromJni,
-				CreateLocalRef              = JavaDoubleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaDoubleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaDoubleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<Double>), new JniMarshalInfo {
-				GetValueFromJni             = JavaDoubleArray.GetValueFromJni,
-				CreateLocalRef              = JavaDoubleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaDoubleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaDoubleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<Double>), new JniMarshalInfo {
-				GetValueFromJni             = JavaDoubleArray.GetValueFromJni,
-				CreateLocalRef              = JavaDoubleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaDoubleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaDoubleArray.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaDoubleArray), new JniMarshalInfo {
-				GetValueFromJni             = JavaDoubleArray.GetValueFromJni,
-				CreateLocalRef              = JavaDoubleArray.CreateLocalRef,
-				CreateMarshalCollection     = JavaDoubleArray.CreateMarshalCollection,
-				CleanupMarshalCollection    = JavaDoubleArray.CleanupMarshalCollection,
-			}),
+		static readonly KeyValuePair<Type, JniValueMarshaler>[] JniPrimitiveArrayMarshalers = new []{
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Boolean[]),                   JavaBooleanArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Boolean>),          JavaBooleanArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Boolean>), JavaBooleanArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaBooleanArray),            JavaBooleanArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (SByte[]),                   JavaSByteArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<SByte>),          JavaSByteArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<SByte>), JavaSByteArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaSByteArray),            JavaSByteArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Char[]),                   JavaCharArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Char>),          JavaCharArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Char>), JavaCharArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaCharArray),            JavaCharArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int16[]),                   JavaInt16Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Int16>),          JavaInt16Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Int16>), JavaInt16Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaInt16Array),            JavaInt16Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int32[]),                   JavaInt32Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Int32>),          JavaInt32Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Int32>), JavaInt32Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaInt32Array),            JavaInt32Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int64[]),                   JavaInt64Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Int64>),          JavaInt64Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Int64>), JavaInt64Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaInt64Array),            JavaInt64Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Single[]),                   JavaSingleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Single>),          JavaSingleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Single>), JavaSingleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaSingleArray),            JavaSingleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Double[]),                   JavaDoubleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<Double>),          JavaDoubleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<Double>), JavaDoubleArray.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaDoubleArray),            JavaDoubleArray.ArrayMarshaler),
 		};
 	}
 
@@ -244,6 +85,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("Z", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaBooleanArray : JavaPrimitiveArray<Boolean> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaBooleanArray (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -338,32 +181,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaBooleanArray) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Boolean>.CreateLocalRef<JavaBooleanArray> (
-		            value,
-		            list => new JavaBooleanArray (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Boolean>> {
 
-		internal static IList<Boolean> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Boolean>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaBooleanArray (ref h, o));
-		}
+			public override IList<Boolean> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Boolean>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaBooleanArray (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Boolean>.CreateMarshalCollection (value, list => new JavaBooleanArray (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Boolean> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Boolean>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaBooleanArray (list)
+						: new JavaBooleanArray (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Boolean>.CleanupMarshalCollection<JavaBooleanArray> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Boolean> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Boolean>.DestroyArgumentState<JavaBooleanArray> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -390,6 +233,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("B", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaSByteArray : JavaPrimitiveArray<SByte> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaSByteArray (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -484,32 +329,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaSByteArray) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<SByte>.CreateLocalRef<JavaSByteArray> (
-		            value,
-		            list => new JavaSByteArray (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<SByte>> {
 
-		internal static IList<SByte> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<SByte>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSByteArray (ref h, o));
-		}
+			public override IList<SByte> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<SByte>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSByteArray (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<SByte>.CreateMarshalCollection (value, list => new JavaSByteArray (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<SByte> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<SByte>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaSByteArray (list)
+						: new JavaSByteArray (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<SByte>.CleanupMarshalCollection<JavaSByteArray> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<SByte> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<SByte>.DestroyArgumentState<JavaSByteArray> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -536,6 +381,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("C", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaCharArray : JavaPrimitiveArray<Char> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaCharArray (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -630,32 +477,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaCharArray) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Char>.CreateLocalRef<JavaCharArray> (
-		            value,
-		            list => new JavaCharArray (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Char>> {
 
-		internal static IList<Char> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Char>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaCharArray (ref h, o));
-		}
+			public override IList<Char> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Char>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaCharArray (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Char>.CreateMarshalCollection (value, list => new JavaCharArray (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Char> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Char>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaCharArray (list)
+						: new JavaCharArray (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Char>.CleanupMarshalCollection<JavaCharArray> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Char> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Char>.DestroyArgumentState<JavaCharArray> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -682,6 +529,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("S", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaInt16Array : JavaPrimitiveArray<Int16> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaInt16Array (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -776,32 +625,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaInt16Array) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Int16>.CreateLocalRef<JavaInt16Array> (
-		            value,
-		            list => new JavaInt16Array (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Int16>> {
 
-		internal static IList<Int16> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Int16>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt16Array (ref h, o));
-		}
+			public override IList<Int16> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Int16>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt16Array (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Int16>.CreateMarshalCollection (value, list => new JavaInt16Array (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Int16> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Int16>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaInt16Array (list)
+						: new JavaInt16Array (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Int16>.CleanupMarshalCollection<JavaInt16Array> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Int16> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Int16>.DestroyArgumentState<JavaInt16Array> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -828,6 +677,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("I", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaInt32Array : JavaPrimitiveArray<Int32> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaInt32Array (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -922,32 +773,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaInt32Array) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Int32>.CreateLocalRef<JavaInt32Array> (
-		            value,
-		            list => new JavaInt32Array (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Int32>> {
 
-		internal static IList<Int32> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Int32>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt32Array (ref h, o));
-		}
+			public override IList<Int32> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Int32>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt32Array (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Int32>.CreateMarshalCollection (value, list => new JavaInt32Array (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Int32> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Int32>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaInt32Array (list)
+						: new JavaInt32Array (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Int32>.CleanupMarshalCollection<JavaInt32Array> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Int32> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Int32>.DestroyArgumentState<JavaInt32Array> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -974,6 +825,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("J", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaInt64Array : JavaPrimitiveArray<Int64> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaInt64Array (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -1068,32 +921,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaInt64Array) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Int64>.CreateLocalRef<JavaInt64Array> (
-		            value,
-		            list => new JavaInt64Array (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Int64>> {
 
-		internal static IList<Int64> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Int64>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt64Array (ref h, o));
-		}
+			public override IList<Int64> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Int64>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaInt64Array (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Int64>.CreateMarshalCollection (value, list => new JavaInt64Array (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Int64> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Int64>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaInt64Array (list)
+						: new JavaInt64Array (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Int64>.CleanupMarshalCollection<JavaInt64Array> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Int64> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Int64>.DestroyArgumentState<JavaInt64Array> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -1120,6 +973,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("F", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaSingleArray : JavaPrimitiveArray<Single> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaSingleArray (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -1214,32 +1069,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaSingleArray) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Single>.CreateLocalRef<JavaSingleArray> (
-		            value,
-		            list => new JavaSingleArray (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Single>> {
 
-		internal static IList<Single> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Single>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSingleArray (ref h, o));
-		}
+			public override IList<Single> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Single>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaSingleArray (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Single>.CreateMarshalCollection (value, list => new JavaSingleArray (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Single> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Single>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaSingleArray (list)
+						: new JavaSingleArray (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Single>.CleanupMarshalCollection<JavaSingleArray> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Single> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Single>.DestroyArgumentState<JavaSingleArray> (value, ref state, synchronize);
+			}
 		}
 	}
 
@@ -1266,6 +1121,8 @@ protected override unsafe void Synchronize (JniReleaseArrayElementsMode releaseM
 	[JniTypeSignature ("D", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class JavaDoubleArray : JavaPrimitiveArray<Double> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public JavaDoubleArray (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -1360,32 +1217,32 @@ internal override bool TargetTypeIsCurrentType (Type targetType)
 				typeof (JavaDoubleArray) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<Double>.CreateLocalRef<JavaDoubleArray> (
-		            value,
-		            list => new JavaDoubleArray (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<Double>> {
 
-		internal static IList<Double> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<Double>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaDoubleArray (ref h, o));
-		}
+			public override IList<Double> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<Double>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new JavaDoubleArray (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<Double>.CreateMarshalCollection (value, list => new JavaDoubleArray (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<Double> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<Double>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new JavaDoubleArray (list)
+						: new JavaDoubleArray (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<Double>.CleanupMarshalCollection<JavaDoubleArray> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<Double> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<Double>.DestroyArgumentState<JavaDoubleArray> (value, ref state, synchronize);
+			}
 		}
 	}
 
diff --git a/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.tt b/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.tt
index 95df44351..82e6702be 100644
--- a/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.tt
+++ b/src/Java.Interop/Java.Interop/JavaPrimitiveArrays.tt
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reflection;
 
 namespace Java.Interop {
 
@@ -34,34 +35,14 @@ namespace Java.Interop {
 #>
 		};
 
-		static readonly KeyValuePair<Type, JniMarshalInfo>[] JniPrimitiveArrayMarshalers = new []{
+		static readonly KeyValuePair<Type, JniValueMarshaler>[] JniPrimitiveArrayMarshalers = new []{
 <#
 	foreach (var info in arrayTypeInfo) {
 #>
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (<#= info.ManagedType #>[]), new JniMarshalInfo {
-				GetValueFromJni             = Java<#= info.TypeModifier #>Array.GetValueFromJni,
-				CreateLocalRef              = Java<#= info.TypeModifier #>Array.CreateLocalRef,
-				CreateMarshalCollection     = Java<#= info.TypeModifier #>Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = Java<#= info.TypeModifier #>Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaArray<<#= info.ManagedType #>>), new JniMarshalInfo {
-				GetValueFromJni             = Java<#= info.TypeModifier #>Array.GetValueFromJni,
-				CreateLocalRef              = Java<#= info.TypeModifier #>Array.CreateLocalRef,
-				CreateMarshalCollection     = Java<#= info.TypeModifier #>Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = Java<#= info.TypeModifier #>Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (JavaPrimitiveArray<<#= info.ManagedType #>>), new JniMarshalInfo {
-				GetValueFromJni             = Java<#= info.TypeModifier #>Array.GetValueFromJni,
-				CreateLocalRef              = Java<#= info.TypeModifier #>Array.CreateLocalRef,
-				CreateMarshalCollection     = Java<#= info.TypeModifier #>Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = Java<#= info.TypeModifier #>Array.CleanupMarshalCollection,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Java<#= info.TypeModifier #>Array), new JniMarshalInfo {
-				GetValueFromJni             = Java<#= info.TypeModifier #>Array.GetValueFromJni,
-				CreateLocalRef              = Java<#= info.TypeModifier #>Array.CreateLocalRef,
-				CreateMarshalCollection     = Java<#= info.TypeModifier #>Array.CreateMarshalCollection,
-				CleanupMarshalCollection    = Java<#= info.TypeModifier #>Array.CleanupMarshalCollection,
-			}),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (<#= info.ManagedType #>[]),                   Java<#= info.TypeModifier #>Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaArray<<#= info.ManagedType #>>),          Java<#= info.TypeModifier #>Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (JavaPrimitiveArray<<#= info.ManagedType #>>), Java<#= info.TypeModifier #>Array.ArrayMarshaler),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Java<#= info.TypeModifier #>Array),            Java<#= info.TypeModifier #>Array.ArrayMarshaler),
 <#
 	}
 #>
@@ -94,6 +75,8 @@ namespace Java.Interop {
 	[JniTypeSignature ("<#= info.JniType #>", ArrayRank=1, IsKeyword=true)]
 	public sealed partial class Java<#= info.TypeModifier #>Array : JavaPrimitiveArray<<#= info.ManagedType #>> {
 
+		internal    static  readonly    ValueMarshaler   ArrayMarshaler     = new ValueMarshaler ();
+
 		public Java<#= info.TypeModifier #>Array (ref JniObjectReference handle, JniObjectReferenceOptions options)
 			: base (ref handle, options)
 		{
@@ -188,32 +171,32 @@ namespace Java.Interop {
 				typeof (Java<#= info.TypeModifier #>Array) == targetType;
 		}
 
-		internal static JniObjectReference CreateLocalRef (object value)
-		{
-		    return JavaArray<<#= info.ManagedType #>>.CreateLocalRef<Java<#= info.TypeModifier #>Array> (
-		            value,
-		            list => new Java<#= info.TypeModifier #>Array (list));
-		}
+		internal sealed class ValueMarshaler : JniValueMarshaler<IList<<#= info.TypeModifier #>>> {
 
-		internal static IList<<#= info.ManagedType #>> GetValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
-		{
-		    return JavaArray<<#= info.ManagedType #>>.GetValueFromJni (
-		            ref reference,
-		            options,
-		            targetType,
-		            (ref JniObjectReference h, JniObjectReferenceOptions o) => new Java<#= info.TypeModifier #>Array (ref h, o));
-		}
+			public override IList<<#= info.TypeModifier #>> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+			{
+				return JavaArray<<#= info.TypeModifier #>>.CreateValue (
+						ref reference,
+						options,
+						targetType,
+						(ref JniObjectReference h, JniObjectReferenceOptions o) => new Java<#= info.TypeModifier #>Array (ref h, o));
+			}
 
-		internal static IJavaPeerable CreateMarshalCollection (object value)
-		{
-		    return JavaArray<<#= info.ManagedType #>>.CreateMarshalCollection (value, list => new Java<#= info.TypeModifier #>Array (list) {
-		        forMarshalCollection = true,
-		    });
-		}
+			public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IList<<#= info.TypeModifier #>> value, ParameterAttributes synchronize)
+			{
+				return JavaArray<<#= info.TypeModifier #>>.CreateArgumentState (value, synchronize, (list, copy) => {
+					var a = copy
+						? new Java<#= info.TypeModifier #>Array (list)
+						: new Java<#= info.TypeModifier #>Array (list.Count);
+					a.forMarshalCollection = true;
+					return a;
+				});
+			}
 
-		internal static void CleanupMarshalCollection (IJavaPeerable marshalObject, object value)
-		{
-		    JavaArray<<#= info.ManagedType #>>.CleanupMarshalCollection<Java<#= info.TypeModifier #>Array> (marshalObject, value);
+			public override void DestroyGenericArgumentState (IList<<#= info.TypeModifier #>> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+			{
+				JavaArray<<#= info.ManagedType #>>.DestroyArgumentState<Java<#= info.TypeModifier #>Array> (value, ref state, synchronize);
+			}
 		}
 	}
 
diff --git a/src/Java.Interop/Java.Interop/JniArgumentValue.cs b/src/Java.Interop/Java.Interop/JniArgumentValue.cs
index b47f9d6f3..3cc96a95a 100644
--- a/src/Java.Interop/Java.Interop/JniArgumentValue.cs
+++ b/src/Java.Interop/Java.Interop/JniArgumentValue.cs
@@ -9,7 +9,7 @@ namespace Android.Runtime
 {
 
 	[StructLayout(LayoutKind.Explicit)]
-	public struct JniArgumentValue {
+	public struct JniArgumentValue : IEquatable<JniArgumentValue> {
 #pragma warning disable 0414
 		[FieldOffset(0)] bool z;
 		[FieldOffset(0)] sbyte b;
@@ -91,10 +91,28 @@ public JniArgumentValue (IJavaPeerable value)
 				l = IntPtr.Zero;
 		}
 
+		public override int GetHashCode ()
+		{
+			return i;
+		}
+
+		public override bool Equals (object obj)
+		{
+			var o   = obj as JniArgumentValue?;
+			if (!o.HasValue)
+				return false;
+			return Equals (o.Value);
+		}
+
+		public bool Equals (JniArgumentValue value)
+		{
+			return j == value.j;
+		}
+
 		public override string ToString ()
 		{
-			return string.Format ("Java.Interop.JniArgumentValue(z={0},b={1},c={2},s={3},i={4},f={5},d={6},l=0x{7})",
-					z, b, c, s, i, f, d, l.ToString ("x"));
+			return string.Format ("JniArgumentValue(z={0},b={1},c={2},s={3},i={4},j={5},f={6},d={7},l=0x{8})",
+					z, b, c, s, i, j, f, d, l.ToString ("x"));
 		}
 	}
 }
diff --git a/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs b/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs
index cd66db186..978dfe01f 100644
--- a/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs
+++ b/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reflection;
 
 namespace Java.Interop {
 
@@ -13,68 +14,41 @@ partial class JniRuntime {
 			new KeyValuePair<Type, JniTypeSignature>(typeof (void),      new JniTypeSignature ("java/lang/Void")),
 
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Boolean),     new JniTypeSignature ("Z", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Boolean),     new JniTypeSignature ("java/lang/Boolean")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Boolean?),    new JniTypeSignature ("java/lang/Boolean")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (SByte),     new JniTypeSignature ("B", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (SByte),     new JniTypeSignature ("java/lang/Byte")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (SByte?),    new JniTypeSignature ("java/lang/Byte")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Char),     new JniTypeSignature ("C", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Char),     new JniTypeSignature ("java/lang/Character")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Char?),    new JniTypeSignature ("java/lang/Character")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Int16),     new JniTypeSignature ("S", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Int16),     new JniTypeSignature ("java/lang/Short")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Int16?),    new JniTypeSignature ("java/lang/Short")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Int32),     new JniTypeSignature ("I", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Int32),     new JniTypeSignature ("java/lang/Integer")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Int32?),    new JniTypeSignature ("java/lang/Integer")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Int64),     new JniTypeSignature ("J", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Int64),     new JniTypeSignature ("java/lang/Long")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Int64?),    new JniTypeSignature ("java/lang/Long")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Single),     new JniTypeSignature ("F", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Single),     new JniTypeSignature ("java/lang/Float")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Single?),    new JniTypeSignature ("java/lang/Float")),
 			new KeyValuePair<Type, JniTypeSignature>(typeof (Double),     new JniTypeSignature ("D", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (Double),     new JniTypeSignature ("java/lang/Double")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (Double?),    new JniTypeSignature ("java/lang/Double")),
 		};
 
-		static readonly KeyValuePair<Type, JniMarshalInfo>[] JniBuiltinMarshalers = new []{
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (string), new JniMarshalInfo {
-				GetValueFromJni             = JniEnvironment.Strings.ToString,
-				CreateLocalRef              = JniEnvironment.Strings.NewString,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Boolean), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniBoolean.CreateJniArgumentValue,
-				GetValueFromJni             = JniBoolean.GetValueFromJni,
-				CreateLocalRef              = JniBoolean.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (SByte), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniByte.CreateJniArgumentValue,
-				GetValueFromJni             = JniByte.GetValueFromJni,
-				CreateLocalRef              = JniByte.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Char), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniCharacter.CreateJniArgumentValue,
-				GetValueFromJni             = JniCharacter.GetValueFromJni,
-				CreateLocalRef              = JniCharacter.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int16), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniShort.CreateJniArgumentValue,
-				GetValueFromJni             = JniShort.GetValueFromJni,
-				CreateLocalRef              = JniShort.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int32), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniInteger.CreateJniArgumentValue,
-				GetValueFromJni             = JniInteger.GetValueFromJni,
-				CreateLocalRef              = JniInteger.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Int64), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniLong.CreateJniArgumentValue,
-				GetValueFromJni             = JniLong.GetValueFromJni,
-				CreateLocalRef              = JniLong.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Single), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniFloat.CreateJniArgumentValue,
-				GetValueFromJni             = JniFloat.GetValueFromJni,
-				CreateLocalRef              = JniFloat.CreateLocalRef,
-			}),
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (Double), new JniMarshalInfo {
-				CreateJniArgumentValue      = JniDouble.CreateJniArgumentValue,
-				GetValueFromJni             = JniDouble.GetValueFromJni,
-				CreateLocalRef              = JniDouble.CreateLocalRef,
-			}),
+		static readonly KeyValuePair<Type, JniValueMarshaler>[] JniBuiltinMarshalers = new []{
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (string), JniStringValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Boolean),   JniBooleanValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Boolean?),  JniNullableBooleanValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (SByte),   JniSByteValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (SByte?),  JniNullableSByteValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Char),   JniCharValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Char?),  JniNullableCharValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int16),   JniInt16ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int16?),  JniNullableInt16ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int32),   JniInt32ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int32?),  JniNullableInt32ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int64),   JniInt64ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Int64?),  JniNullableInt64ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Single),   JniSingleValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Single?),  JniNullableSingleValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Double),   JniDoubleValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (Double?),  JniNullableDoubleValueMarshaler.Instance),
 		};
 	}
 
@@ -86,25 +60,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Boolean) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Boolean value)
 		{
-			Debug.Assert (value is Boolean, "Expected value of type `Boolean`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Boolean) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(Z)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo booleanValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Boolean GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Boolean), "Expected targetType==typeof(Boolean); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref booleanValue, "booleanValue", "()Z");
@@ -116,6 +83,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniBooleanValueMarshaler : JniValueMarshaler<Boolean> {
+
+		internal    static  readonly    JniBooleanValueMarshaler   Instance    = new JniBooleanValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Boolean CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Boolean);
+
+			return JniBoolean.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Boolean value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Boolean value, ParameterAttributes synchronize)
+		{
+			var r = JniBoolean.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Boolean value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableBooleanValueMarshaler : JniValueMarshaler<Boolean?> {
+
+		internal    static  readonly    JniNullableBooleanValueMarshaler   Instance    = new JniNullableBooleanValueMarshaler ();
+
+		public override Boolean? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniBoolean.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Boolean? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniBoolean.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Boolean? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniByte {
 		internal    const   string  JniTypeName = "java/lang/Byte";
 
@@ -124,25 +168,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((SByte) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (SByte value)
 		{
-			Debug.Assert (value is SByte, "Expected value of type `SByte`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((SByte) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(B)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo byteValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static SByte GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (SByte), "Expected targetType==typeof(SByte); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref byteValue, "byteValue", "()B");
@@ -154,6 +191,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniSByteValueMarshaler : JniValueMarshaler<SByte> {
+
+		internal    static  readonly    JniSByteValueMarshaler   Instance    = new JniSByteValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override SByte CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (SByte);
+
+			return JniByte.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (SByte value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (SByte value, ParameterAttributes synchronize)
+		{
+			var r = JniByte.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (SByte value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableSByteValueMarshaler : JniValueMarshaler<SByte?> {
+
+		internal    static  readonly    JniNullableSByteValueMarshaler   Instance    = new JniNullableSByteValueMarshaler ();
+
+		public override SByte? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniByte.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (SByte? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniByte.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (SByte? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniCharacter {
 		internal    const   string  JniTypeName = "java/lang/Character";
 
@@ -162,25 +276,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Char) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Char value)
 		{
-			Debug.Assert (value is Char, "Expected value of type `Char`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Char) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(C)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo charValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Char GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Char), "Expected targetType==typeof(Char); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref charValue, "charValue", "()C");
@@ -192,6 +299,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniCharValueMarshaler : JniValueMarshaler<Char> {
+
+		internal    static  readonly    JniCharValueMarshaler   Instance    = new JniCharValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Char CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Char);
+
+			return JniCharacter.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Char value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Char value, ParameterAttributes synchronize)
+		{
+			var r = JniCharacter.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Char value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableCharValueMarshaler : JniValueMarshaler<Char?> {
+
+		internal    static  readonly    JniNullableCharValueMarshaler   Instance    = new JniNullableCharValueMarshaler ();
+
+		public override Char? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniCharacter.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Char? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniCharacter.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Char? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniShort {
 		internal    const   string  JniTypeName = "java/lang/Short";
 
@@ -200,25 +384,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Int16) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Int16 value)
 		{
-			Debug.Assert (value is Int16, "Expected value of type `Int16`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Int16) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(S)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo shortValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Int16 GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Int16), "Expected targetType==typeof(Int16); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref shortValue, "shortValue", "()S");
@@ -230,6 +407,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniInt16ValueMarshaler : JniValueMarshaler<Int16> {
+
+		internal    static  readonly    JniInt16ValueMarshaler   Instance    = new JniInt16ValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Int16 CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Int16);
+
+			return JniShort.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Int16 value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int16 value, ParameterAttributes synchronize)
+		{
+			var r = JniShort.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Int16 value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableInt16ValueMarshaler : JniValueMarshaler<Int16?> {
+
+		internal    static  readonly    JniNullableInt16ValueMarshaler   Instance    = new JniNullableInt16ValueMarshaler ();
+
+		public override Int16? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniShort.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int16? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniShort.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Int16? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniInteger {
 		internal    const   string  JniTypeName = "java/lang/Integer";
 
@@ -238,25 +492,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Int32) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Int32 value)
 		{
-			Debug.Assert (value is Int32, "Expected value of type `Int32`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Int32) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(I)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo intValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Int32 GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Int32), "Expected targetType==typeof(Int32); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref intValue, "intValue", "()I");
@@ -268,6 +515,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniInt32ValueMarshaler : JniValueMarshaler<Int32> {
+
+		internal    static  readonly    JniInt32ValueMarshaler   Instance    = new JniInt32ValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Int32 CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Int32);
+
+			return JniInteger.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Int32 value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int32 value, ParameterAttributes synchronize)
+		{
+			var r = JniInteger.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Int32 value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableInt32ValueMarshaler : JniValueMarshaler<Int32?> {
+
+		internal    static  readonly    JniNullableInt32ValueMarshaler   Instance    = new JniNullableInt32ValueMarshaler ();
+
+		public override Int32? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniInteger.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int32? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniInteger.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Int32? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniLong {
 		internal    const   string  JniTypeName = "java/lang/Long";
 
@@ -276,25 +600,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Int64) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Int64 value)
 		{
-			Debug.Assert (value is Int64, "Expected value of type `Int64`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Int64) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(J)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo longValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Int64 GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Int64), "Expected targetType==typeof(Int64); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref longValue, "longValue", "()J");
@@ -306,6 +623,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniInt64ValueMarshaler : JniValueMarshaler<Int64> {
+
+		internal    static  readonly    JniInt64ValueMarshaler   Instance    = new JniInt64ValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Int64 CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Int64);
+
+			return JniLong.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Int64 value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int64 value, ParameterAttributes synchronize)
+		{
+			var r = JniLong.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Int64 value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableInt64ValueMarshaler : JniValueMarshaler<Int64?> {
+
+		internal    static  readonly    JniNullableInt64ValueMarshaler   Instance    = new JniNullableInt64ValueMarshaler ();
+
+		public override Int64? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniLong.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Int64? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniLong.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Int64? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniFloat {
 		internal    const   string  JniTypeName = "java/lang/Float";
 
@@ -314,25 +708,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Single) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Single value)
 		{
-			Debug.Assert (value is Single, "Expected value of type `Single`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Single) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(F)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo floatValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Single GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Single), "Expected targetType==typeof(Single); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref floatValue, "floatValue", "()F");
@@ -344,6 +731,83 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 		}
 	}
 
+	class JniSingleValueMarshaler : JniValueMarshaler<Single> {
+
+		internal    static  readonly    JniSingleValueMarshaler   Instance    = new JniSingleValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Single CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Single);
+
+			return JniFloat.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Single value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Single value, ParameterAttributes synchronize)
+		{
+			var r = JniFloat.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Single value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableSingleValueMarshaler : JniValueMarshaler<Single?> {
+
+		internal    static  readonly    JniNullableSingleValueMarshaler   Instance    = new JniNullableSingleValueMarshaler ();
+
+		public override Single? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniFloat.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Single? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniFloat.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Single? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
 	static class JniDouble {
 		internal    const   string  JniTypeName = "java/lang/Double";
 
@@ -352,25 +816,18 @@ static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((Double) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (Double value)
 		{
-			Debug.Assert (value is Double, "Expected value of type `Double`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((Double) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(D)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo doubleValue;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static Double GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (Double), "Expected targetType==typeof(Double); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref doubleValue, "doubleValue", "()D");
@@ -381,4 +838,81 @@ internal static object GetValueFromJni (ref JniObjectReference self, JniObjectRe
 			}
 		}
 	}
+
+	class JniDoubleValueMarshaler : JniValueMarshaler<Double> {
+
+		internal    static  readonly    JniDoubleValueMarshaler   Instance    = new JniDoubleValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override Double CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (Double);
+
+			return JniDouble.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (Double value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Double value, ParameterAttributes synchronize)
+		{
+			var r = JniDouble.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (Double value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullableDoubleValueMarshaler : JniValueMarshaler<Double?> {
+
+		internal    static  readonly    JniNullableDoubleValueMarshaler   Instance    = new JniNullableDoubleValueMarshaler ();
+
+		public override Double? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return JniDouble.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (Double? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = JniDouble.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (Double? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
 }
diff --git a/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt b/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt
index 0b661b250..52f956211 100644
--- a/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt
+++ b/src/Java.Interop/Java.Interop/JniBuiltinMarshalers.tt
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Reflection;
 
 namespace Java.Interop {
 <#
@@ -33,25 +34,19 @@ namespace Java.Interop {
 	foreach (var type in types) {
 #>
 			new KeyValuePair<Type, JniTypeSignature>(typeof (<#= type.Type #>),     new JniTypeSignature ("<#= type.JniType #>", 0, keyword: true)),
-			new KeyValuePair<Type, JniTypeSignature>(typeof (<#= type.Type #>),     new JniTypeSignature ("java/lang/<#= type.Name #>")),
+			new KeyValuePair<Type, JniTypeSignature>(typeof (<#= type.Type #>?),    new JniTypeSignature ("java/lang/<#= type.Name #>")),
 <#
 	}
 #>
 		};
 
-		static readonly KeyValuePair<Type, JniMarshalInfo>[] JniBuiltinMarshalers = new []{
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (string), new JniMarshalInfo {
-				GetValueFromJni             = JniEnvironment.Strings.ToString,
-				CreateLocalRef              = JniEnvironment.Strings.NewString,
-			}),
+		static readonly KeyValuePair<Type, JniValueMarshaler>[] JniBuiltinMarshalers = new []{
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (string), JniStringValueMarshaler.Instance),
 <#
 	foreach (var type in types) {
 #>
-			new KeyValuePair<Type, JniMarshalInfo>(typeof (<#= type.Type #>), new JniMarshalInfo {
-				CreateJniArgumentValue      = Jni<#= type.Name #>.CreateJniArgumentValue,
-				GetValueFromJni             = Jni<#= type.Name #>.GetValueFromJni,
-				CreateLocalRef              = Jni<#= type.Name #>.CreateLocalRef,
-			}),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (<#= type.Type #>),   Jni<#= type.Type #>ValueMarshaler.Instance),
+			new KeyValuePair<Type, JniValueMarshaler>(typeof (<#= type.Type #>?),  JniNullable<#= type.Type #>ValueMarshaler.Instance),
 <#
 	}
 #>
@@ -69,25 +64,18 @@ namespace Java.Interop {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
 		}
 
-		internal static JniArgumentValue CreateJniArgumentValue (object value)
-		{
-			return new JniArgumentValue ((<#= type.Type #>) value);
-		}
-
 		static JniMethodInfo init;
-		internal static unsafe JniObjectReference CreateLocalRef (object value)
+		internal static unsafe JniObjectReference CreateLocalRef (<#= type.Type #> value)
 		{
-			Debug.Assert (value is <#= type.Type #>, "Expected value of type `<#= type.Type #>`; was: " + (value == null ? "<null>" : value.GetType ().FullName));
-
 			var args    = stackalloc JniArgumentValue [1];
-			args [0]    = new JniArgumentValue ((<#= type.Type #>) value);
+			args [0]    = new JniArgumentValue (value);
 
 			TypeRef.GetCachedConstructor (ref init, "(<#= type.JniType #>)V");
 			return TypeRef.NewObject (init, args);
 		}
 
 		static JniMethodInfo <#= type.GetValue #>;
-		internal static object GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
+		internal static <#= type.Type #> GetValueFromJni (ref JniObjectReference self, JniObjectReferenceOptions transfer, Type targetType)
 		{
 			Debug.Assert (targetType == null || targetType == typeof (<#= type.Type #>), "Expected targetType==typeof(<#= type.Type #>); was: " + targetType);
 			TypeRef.GetCachedInstanceMethod (ref <#= type.GetValue #>, "<#= type.GetValue #>", "()<#= type.JniType #>");
@@ -98,6 +86,83 @@ namespace Java.Interop {
 			}
 		}
 	}
+
+	class Jni<#= type.Type #>ValueMarshaler : JniValueMarshaler<<#= type.Type #>> {
+
+		internal    static  readonly    Jni<#= type.Type #>ValueMarshaler   Instance    = new Jni<#= type.Type #>ValueMarshaler ();
+
+		public override bool IsJniValueType {
+			get {return true;}
+		}
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+			return CreateGenericValue (ref reference, options, targetType);
+		}
+
+		public override <#= type.Type #> CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return default (<#= type.Type #>);
+
+			return Jni<#= type.Name #>.GetValueFromJni (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericArgumentState (<#= type.Type #> value, ParameterAttributes synchronize = ParameterAttributes.In)
+		{
+			return new JniValueMarshalerState (new JniArgumentValue (value));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (<#= type.Type #> value, ParameterAttributes synchronize)
+		{
+			var r = Jni<#= type.Name #>.CreateLocalRef (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+
+		public override void DestroyGenericArgumentState (<#= type.Type #> value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class JniNullable<#= type.Type #>ValueMarshaler : JniValueMarshaler<<#= type.Type #>?> {
+
+		internal    static  readonly    JniNullable<#= type.Type #>ValueMarshaler   Instance    = new JniNullable<#= type.Type #>ValueMarshaler ();
+
+		public override <#= type.Type #>? CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			if (!reference.IsValid)
+				return null;
+
+			return Jni<#= type.Name #>.GetValueFromJni (ref reference, options, targetType: null);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (<#= type.Type #>? value, ParameterAttributes synchronize)
+		{
+		    if (!value.HasValue)
+		        return new JniValueMarshalerState ();
+			var r = Jni<#= type.Name #>.CreateLocalRef (value.Value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (<#= type.Type #>? value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
 <#
 	}
 #>
diff --git a/src/Java.Interop/Java.Interop/JniMarshal.cs b/src/Java.Interop/Java.Interop/JniMarshal.cs
index 9efb67691..56f5303f5 100644
--- a/src/Java.Interop/Java.Interop/JniMarshal.cs
+++ b/src/Java.Interop/Java.Interop/JniMarshal.cs
@@ -1,7 +1,10 @@
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace Java.Interop {
 
@@ -38,59 +41,6 @@ public static bool RecursiveEquals (object objA, object objB)
 			}
 			return false;
 		}
-
-		internal static T GetValue<T> (ref JniObjectReference reference, JniObjectReferenceOptions transfer)
-		{
-			if (!reference.IsValid)
-				return default (T);
-
-			var jvm     = JniEnvironment.Runtime;
-			var target  = jvm.ValueManager.PeekObject (reference);
-			var proxy   = target as JavaProxyObject;
-			if (proxy != null) {
-				JniObjectReference.Dispose (ref reference, transfer);
-				return (T) proxy.Value;
-			}
-
-			if (target is T) {
-				JniObjectReference.Dispose (ref reference, transfer);
-				return (T) target;
-			}
-
-			var info = jvm.ValueManager.GetJniMarshalInfoForType (typeof (T));
-			if (info.GetValueFromJni != null) {
-				return (T) info.GetValueFromJni (ref reference, transfer, typeof (T));
-			}
-
-			var signature   = jvm.TypeManager.GetTypeSignature (JniEnvironment.Types.GetJniTypeNameFromInstance (reference));
-			var targetType  = jvm.TypeManager.GetType (signature);
-			if (targetType != null &&
-					typeof (T).GetTypeInfo ().IsAssignableFrom (targetType.GetTypeInfo ()) &&
-					(info = jvm.ValueManager.GetJniMarshalInfoForType (targetType)).GetValueFromJni != null) {
-				return (T) info.GetValueFromJni (ref reference, transfer, targetType);
-			}
-
-			return (T) jvm.ValueManager.GetObject (ref reference, transfer, typeof (T));
-		}
-
-		public  static JniObjectReference CreateLocalRef<T> (T value)
-		{
-			var jvm     = JniEnvironment.Runtime;
-
-			var info    = new JniMarshalInfo ();
-			if (value != null)
-				info = jvm.ValueManager.GetJniMarshalInfoForType (value.GetType ());
-			if (info.CreateLocalRef == null)
-				info = jvm.ValueManager.GetJniMarshalInfoForType (typeof (T));
-
-			if (info.CreateLocalRef != null) {
-				return info.CreateLocalRef (value);
-			}
-
-			var o = (value as IJavaPeerable) ??
-				JavaProxyObject.GetProxy (value);
-			return jvm.ValueManager.GetJniMarshalInfoForType (typeof (IJavaPeerable)).CreateLocalRef (o);
-		}
 	}
 }
 
diff --git a/src/Java.Interop/Java.Interop/JniMarshalInfo.cs b/src/Java.Interop/Java.Interop/JniMarshalInfo.cs
deleted file mode 100644
index 682db43be..000000000
--- a/src/Java.Interop/Java.Interop/JniMarshalInfo.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System;
-
-namespace Java.Interop {
-
-	using CreateJniArgumentValueHandler     = Func<object /* value */, JniArgumentValue>;
-	using CreateLocalRefHandler             = Func<object /* value */, JniObjectReference>;
-	using CreateMarshalCollectionHandler    = Func<object /* value */, IJavaPeerable>;
-	using CleanupMarshalCollectionHandler   = Action<IJavaPeerable /* sourceValue */, object /* destValue */>;
-
-	public  delegate    object  CreateValueFromJni (ref JniObjectReference reference, JniObjectReferenceOptions transfer, Type targetType);
-
-	public struct JniMarshalInfo {
-
-		public  CreateValueFromJni                  GetValueFromJni;
-		public  CreateJniArgumentValueHandler       CreateJniArgumentValue;
-		public  CreateLocalRefHandler               CreateLocalRef;
-		public  CreateMarshalCollectionHandler      CreateMarshalCollection;
-		public  CleanupMarshalCollectionHandler     CleanupMarshalCollection;
-	}
-}
-
diff --git a/src/Java.Interop/Java.Interop/JniPeerMembers.JniInstanceMethods.cs b/src/Java.Interop/Java.Interop/JniPeerMembers.JniInstanceMethods.cs
index 273ae4f44..63b028ef1 100644
--- a/src/Java.Interop/Java.Interop/JniPeerMembers.JniInstanceMethods.cs
+++ b/src/Java.Interop/Java.Interop/JniPeerMembers.JniInstanceMethods.cs
@@ -149,43 +149,5 @@ public unsafe void FinishCreateInstance (string constructorSignature, IJavaPeera
 		}
 	}
 	}
-
-#if !XA_INTEGRATION
-	struct JniArgumentMarshalInfo<T> {
-		JniArgumentValue                  jvalue;
-		JniObjectReference              lref;
-		IJavaPeerable                     obj;
-		Action<IJavaPeerable, object>     cleanup;
-
-		internal JniArgumentMarshalInfo (T value)
-		{
-			this        = new JniArgumentMarshalInfo<T> ();
-			var jvm     = JniEnvironment.Runtime;
-			var info    = jvm.ValueManager.GetJniMarshalInfoForType (typeof (T));
-			if (info.CreateJniArgumentValue != null)
-				jvalue = info.CreateJniArgumentValue (value);
-			else if (info.CreateMarshalCollection != null) {
-				obj     = info.CreateMarshalCollection (value);
-				jvalue  = new JniArgumentValue (obj);
-			} else if (info.CreateLocalRef != null) {
-				lref    = info.CreateLocalRef (value);
-				jvalue  = new JniArgumentValue (lref);
-			} else
-				throw new NotSupportedException ("Don't know how to get a JniArgumentValue for: " + typeof (T).FullName);
-			cleanup     = info.CleanupMarshalCollection;
-		}
-
-		public JniArgumentValue JniArgumentValue {
-			get {return jvalue;}
-		}
-
-		public  void    Cleanup (object value)
-		{
-			if (cleanup != null && obj != null)
-				cleanup (obj, value);
-			JniObjectReference.Dispose (ref lref, JniObjectReferenceOptions.CopyAndDispose);
-		}
-	}
-#endif  // !XA_INTEGRATION
 }
 
diff --git a/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.cs b/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.cs
index 48260d196..d2ba2e915 100644
--- a/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.cs
+++ b/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.cs
@@ -24,7 +24,8 @@ static unsafe JniObjectReference NewObject<T> (
 		    T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateGenericArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -32,7 +33,7 @@ T value
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -56,7 +57,8 @@ static unsafe void _InvokeConstructor<T> (
 		    T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateGenericArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -66,7 +68,7 @@ T value
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -90,8 +92,10 @@ static unsafe JniObjectReference NewObject<T1, T2> (
 		    T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -100,8 +104,8 @@ static unsafe JniObjectReference NewObject<T1, T2> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -125,8 +129,10 @@ static unsafe void _InvokeConstructor<T1, T2> (
 		    T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -137,8 +143,8 @@ static unsafe void _InvokeConstructor<T1, T2> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -162,9 +168,12 @@ static unsafe JniObjectReference NewObject<T1, T2, T3> (
 		    T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -174,9 +183,9 @@ static unsafe JniObjectReference NewObject<T1, T2, T3> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -200,9 +209,12 @@ static unsafe void _InvokeConstructor<T1, T2, T3> (
 		    T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -214,9 +226,9 @@ static unsafe void _InvokeConstructor<T1, T2, T3> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -240,10 +252,14 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4> (
 		    T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -254,10 +270,10 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -281,10 +297,14 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4> (
 		    T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -297,10 +317,10 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -324,11 +344,16 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -340,11 +365,11 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -368,11 +393,16 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -386,11 +416,11 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -414,12 +444,18 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -432,12 +468,12 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -461,12 +497,18 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -481,12 +523,12 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -510,13 +552,20 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -530,13 +579,13 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -560,13 +609,20 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -582,13 +638,13 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -612,14 +668,22 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -634,14 +698,14 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -665,14 +729,22 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -689,14 +761,14 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -720,15 +792,24 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -744,15 +825,15 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9> (
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -776,15 +857,24 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -802,15 +892,15 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -834,16 +924,26 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -860,16 +960,16 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -893,16 +993,26 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> (
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -921,16 +1031,16 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> (
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -954,17 +1064,28 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -982,17 +1103,17 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -1016,17 +1137,28 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -1046,17 +1178,17 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -1080,18 +1212,30 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -1110,18 +1254,18 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -1145,18 +1289,30 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -1177,18 +1333,18 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -1212,19 +1368,32 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -1244,19 +1413,19 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -1280,19 +1449,32 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -1314,19 +1496,19 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -1350,20 +1532,34 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -1384,20 +1580,20 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -1421,20 +1617,34 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -1457,20 +1667,20 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -1494,21 +1704,36 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -1530,21 +1755,21 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -1568,21 +1793,36 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -1606,21 +1846,21 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -1644,22 +1884,38 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateGenericArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -1682,22 +1938,22 @@ static unsafe JniObjectReference NewObject<T1, T2, T3, T4, T5, T6, T7, T8, T9, T
 			try {
 			    return peer.NewObject (constructorSignature, declaringType, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
+				__vm16.DestroyGenericArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -1721,22 +1977,38 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 		    T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateGenericArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -1761,22 +2033,22 @@ static unsafe void _InvokeConstructor<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T
 				var ctor    = methods.GetConstructor (constructorSignature);
 				JniEnvironment.InstanceMethods.CallNonvirtualVoidMethod (self.PeerReference, methods.JniPeerType.PeerReference, ctor, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
+				__vm16.DestroyGenericArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -1802,7 +2074,8 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateGenericArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -1810,7 +2083,7 @@ T value
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -1821,8 +2094,10 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -1831,8 +2106,8 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2> (
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -1843,9 +2118,12 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -1855,9 +2133,9 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3> (
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -1868,10 +2146,14 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -1882,10 +2164,10 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4> (
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -1896,11 +2178,16 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -1912,11 +2199,11 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5> (
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -1927,12 +2214,18 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -1945,12 +2238,12 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6>
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -1961,13 +2254,20 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -1981,13 +2281,13 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -1998,14 +2298,22 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -2020,14 +2328,14 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -2038,15 +2346,24 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -2062,15 +2379,15 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -2081,16 +2398,26 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -2107,16 +2434,16 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -2127,17 +2454,28 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -2155,17 +2493,17 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -2176,18 +2514,30 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -2206,18 +2556,18 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -2228,19 +2578,32 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -2260,19 +2623,19 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -2283,20 +2646,34 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -2317,20 +2694,20 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -2341,21 +2718,36 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -2377,21 +2769,21 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -2402,22 +2794,38 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateGenericArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -2440,22 +2848,22 @@ public static unsafe void InvokeGenericVirtualVoidMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				peer.InvokeVirtualVoidMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
+				__vm16.DestroyGenericArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -2481,7 +2889,8 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateGenericArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -2489,7 +2898,7 @@ T value
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -2500,8 +2909,10 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -2510,8 +2921,8 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2> (
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -2522,9 +2933,12 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -2534,9 +2948,9 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -2547,10 +2961,14 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -2561,10 +2979,10 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -2575,11 +2993,16 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -2591,11 +3014,11 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5>
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -2606,12 +3029,18 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -2624,12 +3053,12 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -2640,13 +3069,20 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -2660,13 +3096,13 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -2677,14 +3113,22 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -2699,14 +3143,14 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -2717,15 +3161,24 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -2741,15 +3194,15 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -2760,16 +3213,26 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -2786,16 +3249,16 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -2806,17 +3269,28 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -2834,17 +3308,17 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -2855,18 +3329,30 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -2885,18 +3371,18 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -2907,19 +3393,32 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -2939,19 +3438,19 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -2962,20 +3461,34 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -2996,20 +3509,20 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -3020,21 +3533,36 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -3056,21 +3584,21 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -3081,22 +3609,38 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateGenericArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateGenericArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateGenericArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateGenericArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateGenericArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateGenericArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateGenericArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -3119,22 +3663,22 @@ public static unsafe bool InvokeGenericVirtualBooleanMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualBooleanMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
+				__vm16.DestroyGenericArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -3160,7 +3704,8 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateGenericArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -3168,7 +3713,7 @@ T value
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -3179,8 +3724,10 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -3189,8 +3736,8 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2> (
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -3201,9 +3748,12 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -3213,9 +3763,9 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -3226,10 +3776,14 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -3240,10 +3794,10 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -3254,11 +3808,16 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -3270,11 +3829,11 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -3285,12 +3844,18 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -3303,12 +3868,12 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -3319,13 +3884,20 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -3339,13 +3911,13 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -3356,14 +3928,22 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -3378,14 +3958,14 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -3396,15 +3976,24 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateGenericArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateGenericArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateGenericArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -3420,15 +4009,15 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -3439,16 +4028,26 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateGenericArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateGenericArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateGenericArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateGenericArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateGenericArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateGenericArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -3465,16 +4064,16 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -3485,17 +4084,28 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -3513,17 +4123,17 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -3534,18 +4144,30 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -3564,18 +4186,18 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -3586,19 +4208,32 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -3618,19 +4253,19 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -3641,20 +4276,34 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -3675,20 +4324,20 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -3699,21 +4348,36 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -3735,21 +4399,21 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -3760,22 +4424,38 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -3798,22 +4478,22 @@ public static unsafe sbyte InvokeGenericVirtualSByteMethod<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualSByteMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
+				__vm14.DestroyGenericArgumentState (value14, ref arg14);
+				__vm15.DestroyGenericArgumentState (value15, ref arg15);
+				__vm16.DestroyGenericArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -3839,7 +4519,8 @@ public static unsafe char InvokeGenericVirtualCharMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -3847,7 +4528,7 @@ T value
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyGenericArgumentState (value, ref arg);
 			}
 		}
 
@@ -3858,8 +4539,10 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -3868,8 +4551,8 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2> (
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -3880,9 +4563,12 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -3892,9 +4578,9 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -3905,10 +4591,14 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -3919,10 +4609,10 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -3933,11 +4623,16 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -3949,11 +4644,11 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -3964,12 +4659,18 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -3982,12 +4683,12 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6>
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -3998,13 +4699,20 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -4018,13 +4726,13 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -4035,14 +4743,22 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -4057,14 +4773,14 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -4075,15 +4791,24 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -4099,15 +4824,15 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -4118,16 +4843,26 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -4144,16 +4879,16 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -4164,17 +4899,28 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -4192,17 +4938,17 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -4213,18 +4959,30 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -4243,18 +5001,18 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -4265,19 +5023,32 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -4297,19 +5068,19 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyGenericArgumentState (value1, ref arg1);
+				__vm2.DestroyGenericArgumentState (value2, ref arg2);
+				__vm3.DestroyGenericArgumentState (value3, ref arg3);
+				__vm4.DestroyGenericArgumentState (value4, ref arg4);
+				__vm5.DestroyGenericArgumentState (value5, ref arg5);
+				__vm6.DestroyGenericArgumentState (value6, ref arg6);
+				__vm7.DestroyGenericArgumentState (value7, ref arg7);
+				__vm8.DestroyGenericArgumentState (value8, ref arg8);
+				__vm9.DestroyGenericArgumentState (value9, ref arg9);
+				__vm10.DestroyGenericArgumentState (value10, ref arg10);
+				__vm11.DestroyGenericArgumentState (value11, ref arg11);
+				__vm12.DestroyGenericArgumentState (value12, ref arg12);
+				__vm13.DestroyGenericArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -4320,20 +5091,34 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -4354,20 +5139,20 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -4378,21 +5163,36 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -4414,21 +5214,21 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -4439,22 +5239,38 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -4477,22 +5293,22 @@ public static unsafe char InvokeGenericVirtualCharMethod<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualCharMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -4518,7 +5334,8 @@ public static unsafe short InvokeGenericVirtualInt16Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -4526,7 +5343,7 @@ T value
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -4537,8 +5354,10 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -4547,8 +5366,8 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2> (
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -4559,9 +5378,12 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -4571,9 +5393,9 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -4584,10 +5406,14 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -4598,10 +5424,10 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -4612,11 +5438,16 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -4628,11 +5459,11 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -4643,12 +5474,18 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -4661,12 +5498,12 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -4677,13 +5514,20 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -4697,13 +5541,13 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -4714,14 +5558,22 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -4736,14 +5588,14 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -4754,15 +5606,24 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -4778,15 +5639,15 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -4797,16 +5658,26 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -4823,16 +5694,16 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -4843,17 +5714,28 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -4871,17 +5753,17 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -4892,18 +5774,30 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -4922,18 +5816,18 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -4944,19 +5838,32 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -4976,19 +5883,19 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -4999,20 +5906,34 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -5033,20 +5954,20 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -5057,21 +5978,36 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -5093,21 +6029,21 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -5118,22 +6054,38 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -5156,22 +6108,22 @@ public static unsafe short InvokeGenericVirtualInt16Method<T1, T2, T3, T4, T5, T
 			try {
 				return peer.InvokeVirtualInt16Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -5197,7 +6149,8 @@ public static unsafe int InvokeGenericVirtualInt32Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -5205,7 +6158,7 @@ T value
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -5216,8 +6169,10 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -5226,8 +6181,8 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2> (
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -5238,9 +6193,12 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -5250,9 +6208,9 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -5263,10 +6221,14 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -5277,10 +6239,10 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -5291,11 +6253,16 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -5307,11 +6274,11 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -5322,12 +6289,18 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -5340,12 +6313,12 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6>
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -5356,13 +6329,20 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -5376,13 +6356,13 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -5393,14 +6373,22 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -5415,14 +6403,14 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -5433,15 +6421,24 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -5457,15 +6454,15 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -5476,16 +6473,26 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -5502,16 +6509,16 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -5522,17 +6529,28 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -5550,17 +6568,17 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -5571,18 +6589,30 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -5601,18 +6631,18 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -5623,19 +6653,32 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -5655,19 +6698,19 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -5678,20 +6721,34 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -5712,20 +6769,20 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -5736,21 +6793,36 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -5772,21 +6844,21 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -5797,22 +6869,38 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -5835,22 +6923,22 @@ public static unsafe int InvokeGenericVirtualInt32Method<T1, T2, T3, T4, T5, T6,
 			try {
 				return peer.InvokeVirtualInt32Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -5876,7 +6964,8 @@ public static unsafe long InvokeGenericVirtualInt64Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -5884,7 +6973,7 @@ T value
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -5895,8 +6984,10 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -5905,8 +6996,8 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2> (
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -5917,9 +7008,12 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -5929,9 +7023,9 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -5942,10 +7036,14 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -5956,10 +7054,10 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -5970,11 +7068,16 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -5986,11 +7089,11 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -6001,12 +7104,18 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -6019,12 +7128,12 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -6035,13 +7144,20 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -6055,13 +7171,13 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -6072,14 +7188,22 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -6094,14 +7218,14 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -6112,15 +7236,24 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -6136,15 +7269,15 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -6155,16 +7288,26 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -6181,16 +7324,16 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -6201,17 +7344,28 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -6229,17 +7383,17 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -6250,18 +7404,30 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -6280,18 +7446,18 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -6302,19 +7468,32 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -6334,19 +7513,19 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -6357,20 +7536,34 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -6391,20 +7584,20 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -6415,21 +7608,36 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -6451,21 +7659,21 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -6476,22 +7684,38 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -6514,22 +7738,22 @@ public static unsafe long InvokeGenericVirtualInt64Method<T1, T2, T3, T4, T5, T6
 			try {
 				return peer.InvokeVirtualInt64Method (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -6555,7 +7779,8 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -6563,7 +7788,7 @@ T value
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -6574,8 +7799,10 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -6584,8 +7811,8 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2> (
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -6596,9 +7823,12 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -6608,9 +7838,9 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -6621,10 +7851,14 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -6635,10 +7869,10 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -6649,11 +7883,16 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -6665,11 +7904,11 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5>
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -6680,12 +7919,18 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -6698,12 +7943,12 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -6714,13 +7959,20 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -6734,13 +7986,13 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -6751,14 +8003,22 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -6773,14 +8033,14 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -6791,15 +8051,24 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -6815,15 +8084,15 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -6834,16 +8103,26 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -6860,16 +8139,16 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -6880,17 +8159,28 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -6908,17 +8198,17 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -6929,18 +8219,30 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -6959,18 +8261,18 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -6981,19 +8283,32 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -7013,19 +8328,19 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -7036,20 +8351,34 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -7070,20 +8399,20 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -7094,21 +8423,36 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -7130,21 +8474,21 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -7155,22 +8499,38 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -7193,22 +8553,22 @@ public static unsafe float InvokeGenericVirtualSingleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualSingleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -7234,7 +8594,8 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -7242,7 +8603,7 @@ T value
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -7253,8 +8614,10 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -7263,8 +8626,8 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2> (
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -7275,9 +8638,12 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -7287,9 +8653,9 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -7300,10 +8666,14 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -7314,10 +8684,10 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -7328,11 +8698,16 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -7344,11 +8719,11 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5>
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -7359,12 +8734,18 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -7377,12 +8758,12 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -7393,13 +8774,20 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -7413,13 +8801,13 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -7430,14 +8818,22 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -7452,14 +8848,14 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -7470,15 +8866,24 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -7494,15 +8899,15 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -7513,16 +8918,26 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -7539,16 +8954,16 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -7559,17 +8974,28 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -7587,17 +9013,17 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -7608,18 +9034,30 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -7638,18 +9076,18 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -7660,19 +9098,32 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -7692,19 +9143,19 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -7715,20 +9166,34 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -7749,20 +9214,20 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -7773,21 +9238,36 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -7809,21 +9289,21 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -7834,22 +9314,38 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -7872,22 +9368,22 @@ public static unsafe double InvokeGenericVirtualDoubleMethod<T1, T2, T3, T4, T5,
 			try {
 				return peer.InvokeVirtualDoubleMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -7913,7 +9409,8 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -7921,7 +9418,7 @@ T value
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -7932,8 +9429,10 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2>
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -7942,8 +9441,8 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2>
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -7954,9 +9453,12 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -7966,9 +9468,9 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -7979,10 +9481,14 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -7993,10 +9499,10 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -8007,11 +9513,16 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -8023,11 +9534,11 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -8038,12 +9549,18 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -8056,12 +9573,12 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -8072,13 +9589,20 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -8092,13 +9616,13 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -8109,14 +9633,22 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -8131,14 +9663,14 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -8149,15 +9681,24 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -8173,15 +9714,15 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -8192,16 +9733,26 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -8218,16 +9769,16 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -8238,17 +9789,28 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -8266,17 +9828,17 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -8287,18 +9849,30 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -8317,18 +9891,18 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -8339,19 +9913,32 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -8371,19 +9958,19 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -8394,20 +9981,34 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -8428,20 +10029,20 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -8452,21 +10053,36 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -8488,21 +10104,21 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -8513,22 +10129,38 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -8551,22 +10183,22 @@ public static unsafe JniObjectReference InvokeGenericVirtualObjectMethod<T1, T2,
 			try {
 				return peer.InvokeVirtualObjectMethod (encodedMember, self, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 	}
@@ -8580,7 +10212,8 @@ public static unsafe void InvokeGenericVoidMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -8588,7 +10221,7 @@ T value
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -8598,8 +10231,10 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -8608,8 +10243,8 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -8619,9 +10254,12 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -8631,9 +10269,9 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -8643,10 +10281,14 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -8657,10 +10299,10 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -8670,11 +10312,16 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -8686,11 +10333,11 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -8700,12 +10347,18 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -8718,12 +10371,12 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -8733,13 +10386,20 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -8753,13 +10413,13 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7> (
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -8769,14 +10429,22 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -8791,14 +10459,14 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -8808,15 +10476,24 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -8832,15 +10509,15 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -8850,16 +10527,26 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -8876,16 +10563,16 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -8895,17 +10582,28 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -8923,17 +10621,17 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -8943,18 +10641,30 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -8973,18 +10683,18 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -8994,19 +10704,32 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -9026,19 +10749,19 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -9048,20 +10771,34 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -9082,20 +10819,20 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -9105,21 +10842,36 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -9141,21 +10893,21 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -9165,22 +10917,38 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -9203,22 +10971,22 @@ public static unsafe void InvokeGenericVoidMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				peer.InvokeVoidMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -9228,7 +10996,8 @@ public static unsafe bool InvokeGenericBooleanMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -9236,7 +11005,7 @@ T value
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -9246,8 +11015,10 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -9256,8 +11027,8 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2> (
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -9267,9 +11038,12 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -9279,9 +11053,9 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -9291,10 +11065,14 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -9305,10 +11083,10 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -9318,11 +11096,16 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -9334,11 +11117,11 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -9348,12 +11131,18 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -9366,12 +11155,12 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -9381,13 +11170,20 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -9401,13 +11197,13 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7>
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -9417,14 +11213,22 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -9439,14 +11243,14 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -9456,15 +11260,24 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -9480,15 +11293,15 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -9498,16 +11311,26 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -9524,16 +11347,16 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -9543,17 +11366,28 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -9571,17 +11405,17 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -9591,18 +11425,30 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -9621,18 +11467,18 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -9642,19 +11488,32 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -9674,19 +11533,19 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -9696,20 +11555,34 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -9730,20 +11603,20 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -9753,21 +11626,36 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -9789,21 +11677,21 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -9813,22 +11701,38 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -9851,22 +11755,22 @@ public static unsafe bool InvokeGenericBooleanMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeBooleanMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -9876,7 +11780,8 @@ public static unsafe sbyte InvokeGenericSByteMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -9884,7 +11789,7 @@ T value
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -9894,8 +11799,10 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -9904,8 +11811,8 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2> (
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -9915,9 +11822,12 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -9927,9 +11837,9 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -9939,10 +11849,14 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -9953,10 +11867,10 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -9966,11 +11880,16 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -9982,11 +11901,11 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -9996,12 +11915,18 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -10014,12 +11939,12 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -10029,13 +11954,20 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -10049,13 +11981,13 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7>
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -10065,14 +11997,22 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -10087,14 +12027,14 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -10104,15 +12044,24 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -10128,15 +12077,15 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -10146,16 +12095,26 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -10172,16 +12131,16 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -10191,17 +12150,28 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -10219,17 +12189,17 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -10239,18 +12209,30 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -10269,18 +12251,18 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -10290,19 +12272,32 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -10322,19 +12317,19 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -10344,20 +12339,34 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -10378,20 +12387,20 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -10401,21 +12410,36 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -10437,21 +12461,21 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -10461,22 +12485,38 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -10499,22 +12539,22 @@ public static unsafe sbyte InvokeGenericSByteMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSByteMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -10524,7 +12564,8 @@ public static unsafe char InvokeGenericCharMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -10532,7 +12573,7 @@ T value
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -10542,8 +12583,10 @@ public static unsafe char InvokeGenericCharMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -10552,8 +12595,8 @@ public static unsafe char InvokeGenericCharMethod<T1, T2> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -10563,9 +12606,12 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -10575,9 +12621,9 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -10587,10 +12633,14 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -10601,10 +12651,10 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -10614,11 +12664,16 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -10630,11 +12685,11 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -10644,12 +12699,18 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -10662,12 +12723,12 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -10677,13 +12738,20 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -10697,13 +12765,13 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7> (
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -10713,14 +12781,22 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -10735,14 +12811,14 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -10752,15 +12828,24 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -10776,15 +12861,15 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -10794,16 +12879,26 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -10820,16 +12915,16 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -10839,17 +12934,28 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -10867,17 +12973,17 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -10887,18 +12993,30 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -10917,18 +13035,18 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -10938,19 +13056,32 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -10970,19 +13101,19 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -10992,20 +13123,34 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -11026,20 +13171,20 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -11049,21 +13194,36 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -11085,21 +13245,21 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -11109,22 +13269,38 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -11147,22 +13323,22 @@ public static unsafe char InvokeGenericCharMethod<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeCharMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -11172,7 +13348,8 @@ public static unsafe short InvokeGenericInt16Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -11180,7 +13357,7 @@ T value
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -11190,8 +13367,10 @@ public static unsafe short InvokeGenericInt16Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -11200,8 +13379,8 @@ public static unsafe short InvokeGenericInt16Method<T1, T2> (
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -11211,9 +13390,12 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -11223,9 +13405,9 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3> (
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -11235,10 +13417,14 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -11249,10 +13435,10 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -11262,11 +13448,16 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -11278,11 +13469,11 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -11292,12 +13483,18 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -11310,12 +13507,12 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -11325,13 +13522,20 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -11345,13 +13549,13 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7>
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -11361,14 +13565,22 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -11383,14 +13595,14 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -11400,15 +13612,24 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -11424,15 +13645,15 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -11442,16 +13663,26 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -11468,16 +13699,16 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -11487,17 +13718,28 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -11515,17 +13757,17 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -11535,18 +13777,30 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -11565,18 +13819,18 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -11586,19 +13840,32 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -11618,19 +13885,19 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -11640,20 +13907,34 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -11674,20 +13955,20 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -11697,21 +13978,36 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -11733,21 +14029,21 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -11757,22 +14053,38 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -11795,22 +14107,22 @@ public static unsafe short InvokeGenericInt16Method<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeInt16Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -11820,7 +14132,8 @@ public static unsafe int InvokeGenericInt32Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -11828,7 +14141,7 @@ T value
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -11838,8 +14151,10 @@ public static unsafe int InvokeGenericInt32Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -11848,8 +14163,8 @@ public static unsafe int InvokeGenericInt32Method<T1, T2> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -11859,9 +14174,12 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -11871,9 +14189,9 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -11883,10 +14201,14 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -11897,10 +14219,10 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -11910,11 +14232,16 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -11926,11 +14253,11 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -11940,12 +14267,18 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -11958,12 +14291,12 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -11973,13 +14306,20 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -11993,13 +14333,13 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7> (
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -12009,14 +14349,22 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -12031,14 +14379,14 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -12048,15 +14396,24 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -12072,15 +14429,15 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -12090,16 +14447,26 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -12116,16 +14483,16 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -12135,17 +14502,28 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -12163,17 +14541,17 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -12183,18 +14561,30 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -12213,18 +14603,18 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -12234,19 +14624,32 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -12266,19 +14669,19 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -12288,20 +14691,34 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -12322,20 +14739,20 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -12345,21 +14762,36 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -12381,21 +14813,21 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -12405,22 +14837,38 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -12443,22 +14891,22 @@ public static unsafe int InvokeGenericInt32Method<T1, T2, T3, T4, T5, T6, T7, T8
 			try {
 				return peer.InvokeInt32Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -12468,7 +14916,8 @@ public static unsafe long InvokeGenericInt64Method<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -12476,7 +14925,7 @@ T value
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -12486,8 +14935,10 @@ public static unsafe long InvokeGenericInt64Method<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -12496,8 +14947,8 @@ public static unsafe long InvokeGenericInt64Method<T1, T2> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -12507,9 +14958,12 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -12519,9 +14973,9 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -12531,10 +14985,14 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -12545,10 +15003,10 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -12558,11 +15016,16 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -12574,11 +15037,11 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -12588,12 +15051,18 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -12606,12 +15075,12 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -12621,13 +15090,20 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -12641,13 +15117,13 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7> (
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -12657,14 +15133,22 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -12679,14 +15163,14 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -12696,15 +15180,24 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -12720,15 +15213,15 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -12738,16 +15231,26 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -12764,16 +15267,16 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -12783,17 +15286,28 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -12811,17 +15325,17 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -12831,18 +15345,30 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -12861,18 +15387,18 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -12882,19 +15408,32 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -12914,19 +15453,19 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -12936,20 +15475,34 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -12970,20 +15523,20 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -12993,21 +15546,36 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -13029,21 +15597,21 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -13053,22 +15621,38 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -13091,22 +15675,22 @@ public static unsafe long InvokeGenericInt64Method<T1, T2, T3, T4, T5, T6, T7, T
 			try {
 				return peer.InvokeInt64Method (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -13116,7 +15700,8 @@ public static unsafe float InvokeGenericSingleMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -13124,7 +15709,7 @@ T value
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -13134,8 +15719,10 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -13144,8 +15731,8 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2> (
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -13155,9 +15742,12 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -13167,9 +15757,9 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -13179,10 +15769,14 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -13193,10 +15787,10 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -13206,11 +15800,16 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -13222,11 +15821,11 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -13236,12 +15835,18 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -13254,12 +15859,12 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -13269,13 +15874,20 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7>
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -13289,13 +15901,13 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7>
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -13305,14 +15917,22 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -13327,14 +15947,14 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -13344,15 +15964,24 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -13368,15 +15997,15 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -13386,16 +16015,26 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -13412,16 +16051,16 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -13431,17 +16070,28 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -13459,17 +16109,17 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -13479,18 +16129,30 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -13509,18 +16171,18 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -13530,19 +16192,32 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -13562,19 +16237,19 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -13584,20 +16259,34 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -13618,20 +16307,20 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -13641,21 +16330,36 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -13677,21 +16381,21 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -13701,22 +16405,38 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -13739,22 +16459,22 @@ public static unsafe float InvokeGenericSingleMethod<T1, T2, T3, T4, T5, T6, T7,
 			try {
 				return peer.InvokeSingleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -13764,7 +16484,8 @@ public static unsafe double InvokeGenericDoubleMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -13772,7 +16493,7 @@ T value
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -13782,8 +16503,10 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -13792,8 +16515,8 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2> (
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -13803,9 +16526,12 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -13815,9 +16541,9 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -13827,10 +16553,14 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4> (
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -13841,10 +16571,10 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4> (
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -13854,11 +16584,16 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -13870,11 +16605,11 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5> (
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -13884,12 +16619,18 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6> (
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -13902,12 +16643,12 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6> (
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -13917,13 +16658,20 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -13937,13 +16685,13 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -13953,14 +16701,22 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -13975,14 +16731,14 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -13992,15 +16748,24 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -14016,15 +16781,15 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -14034,16 +16799,26 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -14060,16 +16835,16 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -14079,17 +16854,28 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -14107,17 +16893,17 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -14127,18 +16913,30 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -14157,18 +16955,18 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -14178,19 +16976,32 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -14210,19 +17021,19 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -14232,20 +17043,34 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -14266,20 +17091,20 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -14289,21 +17114,36 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -14325,21 +17165,21 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -14349,22 +17189,38 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -14387,22 +17243,22 @@ public static unsafe double InvokeGenericDoubleMethod<T1, T2, T3, T4, T5, T6, T7
 			try {
 				return peer.InvokeDoubleMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 
@@ -14412,7 +17268,8 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T> (
 			T value
 		)
 		{
-			JniArgumentMarshalInfo<T> arg = new JniArgumentMarshalInfo<T>(value);
+			var __vm = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T> ();
+			var arg = __vm.CreateArgumentState (value);
 
 			var args = stackalloc JniArgumentValue [1];
 			args [0] = arg.JniArgumentValue;
@@ -14420,7 +17277,7 @@ T value
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg.Cleanup (value);
+				__vm.DestroyArgumentState (value, ref arg);
 			}
 		}
 
@@ -14430,8 +17287,10 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2> (
 			T1 value1, T2 value2
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
 
 			var args = stackalloc JniArgumentValue [2];
 			args [0] = arg1.JniArgumentValue;
@@ -14440,8 +17299,8 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2> (
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
 			}
 		}
 
@@ -14451,9 +17310,12 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3> (
 			T1 value1, T2 value2, T3 value3
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
 
 			var args = stackalloc JniArgumentValue [3];
 			args [0] = arg1.JniArgumentValue;
@@ -14463,9 +17325,9 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3> (
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
 			}
 		}
 
@@ -14475,10 +17337,14 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
 
 			var args = stackalloc JniArgumentValue [4];
 			args [0] = arg1.JniArgumentValue;
@@ -14489,10 +17355,10 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
 			}
 		}
 
@@ -14502,11 +17368,16 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
 
 			var args = stackalloc JniArgumentValue [5];
 			args [0] = arg1.JniArgumentValue;
@@ -14518,11 +17389,11 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
 			}
 		}
 
@@ -14532,12 +17403,18 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
 
 			var args = stackalloc JniArgumentValue [6];
 			args [0] = arg1.JniArgumentValue;
@@ -14550,12 +17427,12 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
 			}
 		}
 
@@ -14565,13 +17442,20 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
 
 			var args = stackalloc JniArgumentValue [7];
 			args [0] = arg1.JniArgumentValue;
@@ -14585,13 +17469,13 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
 			}
 		}
 
@@ -14601,14 +17485,22 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
 
 			var args = stackalloc JniArgumentValue [8];
 			args [0] = arg1.JniArgumentValue;
@@ -14623,14 +17515,14 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
 			}
 		}
 
@@ -14640,15 +17532,24 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
 
 			var args = stackalloc JniArgumentValue [9];
 			args [0] = arg1.JniArgumentValue;
@@ -14664,15 +17565,15 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
 			}
 		}
 
@@ -14682,16 +17583,26 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
 
 			var args = stackalloc JniArgumentValue [10];
 			args [0] = arg1.JniArgumentValue;
@@ -14708,16 +17619,16 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
 			}
 		}
 
@@ -14727,17 +17638,28 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
 
 			var args = stackalloc JniArgumentValue [11];
 			args [0] = arg1.JniArgumentValue;
@@ -14755,17 +17677,17 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
 			}
 		}
 
@@ -14775,18 +17697,30 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
 
 			var args = stackalloc JniArgumentValue [12];
 			args [0] = arg1.JniArgumentValue;
@@ -14805,18 +17739,18 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
 			}
 		}
 
@@ -14826,19 +17760,32 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
 
 			var args = stackalloc JniArgumentValue [13];
 			args [0] = arg1.JniArgumentValue;
@@ -14858,19 +17805,19 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
 			}
 		}
 
@@ -14880,20 +17827,34 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
 
 			var args = stackalloc JniArgumentValue [14];
 			args [0] = arg1.JniArgumentValue;
@@ -14914,20 +17875,20 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
 			}
 		}
 
@@ -14937,21 +17898,36 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
 
 			var args = stackalloc JniArgumentValue [15];
 			args [0] = arg1.JniArgumentValue;
@@ -14973,21 +17949,21 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
 			}
 		}
 
@@ -14997,22 +17973,38 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16
 		)
 		{
-			JniArgumentMarshalInfo<T1> arg1 = new JniArgumentMarshalInfo<T1>(value1);
-			JniArgumentMarshalInfo<T2> arg2 = new JniArgumentMarshalInfo<T2>(value2);
-			JniArgumentMarshalInfo<T3> arg3 = new JniArgumentMarshalInfo<T3>(value3);
-			JniArgumentMarshalInfo<T4> arg4 = new JniArgumentMarshalInfo<T4>(value4);
-			JniArgumentMarshalInfo<T5> arg5 = new JniArgumentMarshalInfo<T5>(value5);
-			JniArgumentMarshalInfo<T6> arg6 = new JniArgumentMarshalInfo<T6>(value6);
-			JniArgumentMarshalInfo<T7> arg7 = new JniArgumentMarshalInfo<T7>(value7);
-			JniArgumentMarshalInfo<T8> arg8 = new JniArgumentMarshalInfo<T8>(value8);
-			JniArgumentMarshalInfo<T9> arg9 = new JniArgumentMarshalInfo<T9>(value9);
-			JniArgumentMarshalInfo<T10> arg10 = new JniArgumentMarshalInfo<T10>(value10);
-			JniArgumentMarshalInfo<T11> arg11 = new JniArgumentMarshalInfo<T11>(value11);
-			JniArgumentMarshalInfo<T12> arg12 = new JniArgumentMarshalInfo<T12>(value12);
-			JniArgumentMarshalInfo<T13> arg13 = new JniArgumentMarshalInfo<T13>(value13);
-			JniArgumentMarshalInfo<T14> arg14 = new JniArgumentMarshalInfo<T14>(value14);
-			JniArgumentMarshalInfo<T15> arg15 = new JniArgumentMarshalInfo<T15>(value15);
-			JniArgumentMarshalInfo<T16> arg16 = new JniArgumentMarshalInfo<T16>(value16);
+			var __vm1 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T1> ();
+			var arg1 = __vm1.CreateArgumentState (value1);
+			var __vm2 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T2> ();
+			var arg2 = __vm2.CreateArgumentState (value2);
+			var __vm3 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T3> ();
+			var arg3 = __vm3.CreateArgumentState (value3);
+			var __vm4 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T4> ();
+			var arg4 = __vm4.CreateArgumentState (value4);
+			var __vm5 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T5> ();
+			var arg5 = __vm5.CreateArgumentState (value5);
+			var __vm6 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T6> ();
+			var arg6 = __vm6.CreateArgumentState (value6);
+			var __vm7 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T7> ();
+			var arg7 = __vm7.CreateArgumentState (value7);
+			var __vm8 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T8> ();
+			var arg8 = __vm8.CreateArgumentState (value8);
+			var __vm9 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T9> ();
+			var arg9 = __vm9.CreateArgumentState (value9);
+			var __vm10 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T10> ();
+			var arg10 = __vm10.CreateArgumentState (value10);
+			var __vm11 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T11> ();
+			var arg11 = __vm11.CreateArgumentState (value11);
+			var __vm12 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T12> ();
+			var arg12 = __vm12.CreateArgumentState (value12);
+			var __vm13 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T13> ();
+			var arg13 = __vm13.CreateArgumentState (value13);
+			var __vm14 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T14> ();
+			var arg14 = __vm14.CreateArgumentState (value14);
+			var __vm15 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T15> ();
+			var arg15 = __vm15.CreateArgumentState (value15);
+			var __vm16 = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<T16> ();
+			var arg16 = __vm16.CreateArgumentState (value16);
 
 			var args = stackalloc JniArgumentValue [16];
 			args [0] = arg1.JniArgumentValue;
@@ -15035,22 +18027,22 @@ public static unsafe JniObjectReference InvokeGenericObjectMethod<T1, T2, T3, T4
 			try {
 				return peer.InvokeObjectMethod (encodedMember, args);
 			} finally {
-				arg1.Cleanup (value1);
-				arg2.Cleanup (value2);
-				arg3.Cleanup (value3);
-				arg4.Cleanup (value4);
-				arg5.Cleanup (value5);
-				arg6.Cleanup (value6);
-				arg7.Cleanup (value7);
-				arg8.Cleanup (value8);
-				arg9.Cleanup (value9);
-				arg10.Cleanup (value10);
-				arg11.Cleanup (value11);
-				arg12.Cleanup (value12);
-				arg13.Cleanup (value13);
-				arg14.Cleanup (value14);
-				arg15.Cleanup (value15);
-				arg16.Cleanup (value16);
+				__vm1.DestroyArgumentState (value1, ref arg1);
+				__vm2.DestroyArgumentState (value2, ref arg2);
+				__vm3.DestroyArgumentState (value3, ref arg3);
+				__vm4.DestroyArgumentState (value4, ref arg4);
+				__vm5.DestroyArgumentState (value5, ref arg5);
+				__vm6.DestroyArgumentState (value6, ref arg6);
+				__vm7.DestroyArgumentState (value7, ref arg7);
+				__vm8.DestroyArgumentState (value8, ref arg8);
+				__vm9.DestroyArgumentState (value9, ref arg9);
+				__vm10.DestroyArgumentState (value10, ref arg10);
+				__vm11.DestroyArgumentState (value11, ref arg11);
+				__vm12.DestroyArgumentState (value12, ref arg12);
+				__vm13.DestroyArgumentState (value13, ref arg13);
+				__vm14.DestroyArgumentState (value14, ref arg14);
+				__vm15.DestroyArgumentState (value15, ref arg15);
+				__vm16.DestroyArgumentState (value16, ref arg16);
 			}
 		}
 	}
diff --git a/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.tt b/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.tt
index ca3c836fd..54d135df6 100644
--- a/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.tt
+++ b/src/Java.Interop/Java.Interop/JniPeerMembers.JniMethods.tt
@@ -67,7 +67,10 @@ namespace Java.Interop.GenericMarshaler {
 		{
 <#
 		for (int a = 1; a <= i; ++a) {
-		    WriteLine ("\t\t\tJniArgumentMarshalInfo<{0}> arg{1} = new JniArgumentMarshalInfo<{0}>(value{1});",
+			WriteLine ("\t\t\tvar __vm{1} = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<{0}> ();",
+					i == 1 ? "T" : "T" + a,
+					i == 1 ? "" : a.ToString ());
+			WriteLine ("\t\t\tvar arg{1} = __vm{1}.CreateArgumentState (value{1});",
 		            i == 1 ? "T" : "T" + a,
 		            i == 1 ? "" : a.ToString ());
 		}
@@ -85,7 +88,7 @@ namespace Java.Interop.GenericMarshaler {
 			} finally {
 <#
 		for (int a = 1; a <= i; ++a) {
-		    WriteLine ("\t\t\t\targ{0}.Cleanup (value{0});",
+			WriteLine ("\t\t\t\t__vm{0}.DestroyArgumentState (value{0}, ref arg{0});",
 		            i == 1 ? "" : a.ToString ());
 		}
 #>
@@ -114,7 +117,10 @@ namespace Java.Interop.GenericMarshaler {
 		{
 <#
 		for (int a = 1; a <= i; ++a) {
-		    WriteLine ("\t\t\tJniArgumentMarshalInfo<{0}> arg{1} = new JniArgumentMarshalInfo<{0}>(value{1});",
+			WriteLine ("\t\t\tvar __vm{1} = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<{0}> ();",
+					i == 1 ? "T" : "T" + a,
+					i == 1 ? "" : a.ToString ());
+			WriteLine ("\t\t\tvar arg{1} = __vm{1}.CreateArgumentState (value{1});",
 		            i == 1 ? "T" : "T" + a,
 		            i == 1 ? "" : a.ToString ());
 		}
@@ -134,7 +140,7 @@ namespace Java.Interop.GenericMarshaler {
 			} finally {
 <#
 		for (int a = 1; a <= i; ++a) {
-		    WriteLine ("\t\t\t\targ{0}.Cleanup (value{0});",
+			WriteLine ("\t\t\t\t__vm{0}.DestroyArgumentState (value{0}, ref arg{0});",
 		            i == 1 ? "" : a.ToString ());
 		}
 #>
@@ -186,7 +192,10 @@ namespace Java.Interop.GenericMarshaler {
 		{
 <#
 			for (int a = 1; a <= i; ++a) {
-			    WriteLine ("\t\t\tJniArgumentMarshalInfo<{0}> arg{1} = new JniArgumentMarshalInfo<{0}>(value{1});",
+				WriteLine ("\t\t\tvar __vm{1} = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<{0}> ();",
+						i == 1 ? "T" : "T" + a,
+						i == 1 ? "" : a.ToString ());
+				WriteLine ("\t\t\tvar arg{1} = __vm{1}.CreateArgumentState (value{1});",
 			            i == 1 ? "T" : "T" + a,
 			            i == 1 ? "" : a.ToString ());
 			}
@@ -204,7 +213,7 @@ namespace Java.Interop.GenericMarshaler {
 			} finally {
 <#
 			for (int a = 1; a <= i; ++a) {
-			    WriteLine ("\t\t\t\targ{0}.Cleanup (value{0});",
+				WriteLine ("\t\t\t\t__vm{0}.DestroyArgumentState (value{0}, ref arg{0});",
 			            i == 1 ? "" : a.ToString ());
 			}
 #>
@@ -251,7 +260,10 @@ namespace Java.Interop.GenericMarshaler {
 		{
 <#
 			for (int a = 1; a <= i; ++a) {
-			    WriteLine ("\t\t\tJniArgumentMarshalInfo<{0}> arg{1} = new JniArgumentMarshalInfo<{0}>(value{1});",
+				WriteLine ("\t\t\tvar __vm{1} = JniEnvironment.Runtime.ValueManager.GetValueMarshaler<{0}> ();",
+						i == 1 ? "T" : "T" + a,
+						i == 1 ? "" : a.ToString ());
+				WriteLine ("\t\t\tvar arg{1} = __vm{1}.CreateArgumentState (value{1});",
 			            i == 1 ? "T" : "T" + a,
 			            i == 1 ? "" : a.ToString ());
 			}
@@ -269,7 +281,7 @@ namespace Java.Interop.GenericMarshaler {
 			} finally {
 <#
 			for (int a = 1; a <= i; ++a) {
-			    WriteLine ("\t\t\t\targ{0}.Cleanup (value{0});",
+				WriteLine ("\t\t\t\t__vm{0}.DestroyArgumentState (value{0}, ref arg{0});",
 			            i == 1 ? "" : a.ToString ());
 			}
 #>
diff --git a/src/Java.Interop/Java.Interop/JniRuntime.JniValueManager.cs b/src/Java.Interop/Java.Interop/JniRuntime.JniValueManager.cs
index a3e63f4f4..2d4c4bddd 100644
--- a/src/Java.Interop/Java.Interop/JniRuntime.JniValueManager.cs
+++ b/src/Java.Interop/Java.Interop/JniRuntime.JniValueManager.cs
@@ -354,7 +354,70 @@ public T GetObject<T> (IntPtr jniHandle)
 				return (T) GetObject (jniHandle, typeof(T));
 			}
 
-			public virtual JniMarshalInfo GetJniMarshalInfoForType (Type type)
+			public object GetValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null)
+			{
+				if (!reference.IsValid)
+					return null;
+
+				var target  = PeekObject (reference);
+				var proxy   = target as JavaProxyObject;
+				if (proxy != null) {
+					JniObjectReference.Dispose (ref reference, options);
+					return proxy.Value;
+				}
+
+				if (target != null && (targetType == null || targetType.GetTypeInfo ().IsAssignableFrom (target.GetType ().GetTypeInfo ()))) {
+					JniObjectReference.Dispose (ref reference, options);
+					return target;
+				}
+
+				if (targetType == null) {
+					var signature   = Runtime.TypeManager.GetTypeSignature (JniEnvironment.Types.GetJniTypeNameFromInstance (reference));
+					targetType      = Runtime.TypeManager.GetType (signature);
+				}
+				var vm  = GetValueMarshaler (targetType);
+				return vm.CreateValue (ref reference, options, targetType);
+			}
+
+			public T GetValue<T> (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null)
+			{
+				if (!reference.IsValid)
+					return default (T);
+
+				var target  = PeekObject (reference);
+				var proxy   = target as JavaProxyObject;
+				if (proxy != null) {
+					JniObjectReference.Dispose (ref reference, options);
+					return (T) proxy.Value;
+				}
+
+				if (target is T) {
+					JniObjectReference.Dispose (ref reference, options);
+					return (T) target;
+				}
+
+				var vm  = GetValueMarshaler<T> ();
+				return vm.CreateGenericValue (ref reference, options, typeof (T));
+			}
+
+			Dictionary<Type, JniValueMarshaler> Marshalers = new Dictionary<Type, JniValueMarshaler> ();
+
+			public JniValueMarshaler<T> GetValueMarshaler<T>()
+			{
+				var m   = GetValueMarshaler (typeof (T));
+				var r   = m as JniValueMarshaler<T>;
+				if (r != null)
+					return r;
+				lock (Marshalers) {
+					JniValueMarshaler d;
+					if (Marshalers.TryGetValue (typeof (T), out d))
+						return (JniValueMarshaler<T>) d;
+					Marshalers.Add (typeof (T), d = new DelegatingValueMarshaler<T> (m));
+					return (JniValueMarshaler<T>) d;
+				}
+			}
+
+			public JniValueMarshaler GetValueMarshaler (Type type)
 			{
 				if (type == null)
 					throw new ArgumentNullException ("type");
@@ -363,41 +426,41 @@ public virtual JniMarshalInfo GetJniMarshalInfoForType (Type type)
 					throw new ArgumentException ("Generic type definitions are not supported.", "type");
 
 				if (typeof (IJavaPeerable) == type)
-					return DefaultObjectMarshaler;
+					return JavaPeerableValueMarshaler.Instance;
 
 				foreach (var marshaler in JniBuiltinMarshalers) {
 					if (marshaler.Key == type)
 						return marshaler.Value;
 				}
 
-				var listType = info.ImplementedInterfaces
-					.FirstOrDefault (i => i.GetTypeInfo ().IsGenericType && i.GetGenericTypeDefinition () == typeof (IList<>));
+				var listIface   = typeof(IList<>).GetTypeInfo ();
+				var listType    =
+					(from iface in info.ImplementedInterfaces.Concat (new[]{type})
+					 let iinfo = iface.GetTypeInfo ()
+					 where (listIface).IsAssignableFrom (iinfo.IsGenericType ? iinfo.GetGenericTypeDefinition ().GetTypeInfo () : iinfo)
+					 select iinfo)
+					.FirstOrDefault ();
 				if (listType != null) {
-					var elementType = listType.GetTypeInfo ().GenericTypeArguments [0];
+					var elementType = listType.GenericTypeArguments [0];
 					if (elementType.GetTypeInfo ().IsValueType) {
 						foreach (var marshaler in JniPrimitiveArrayMarshalers) {
-							if (marshaler.Key == type)
+							if (info.IsAssignableFrom (marshaler.Key.GetTypeInfo ()))
 								return marshaler.Value;
 						}
 					}
-					var arrayType   = typeof (JavaObjectArray<>).MakeGenericType (elementType);
-					var getValue    = CreateMethodDelegate<CreateValueFromJni> (arrayType, "GetValue");
-					var createLRef  = CreateMethodDelegate<Func<object, JniObjectReference>> (arrayType, "CreateLocalRef");
-					var createObj   = CreateMethodDelegate<Func<object, IJavaPeerable>> (arrayType, "CreateMarshalCollection");
-					var cleanup     = CreateMethodDelegate<Action<IJavaPeerable, object>> (arrayType, "CleanupMarshalCollection");
-
-					return new JniMarshalInfo {
-						GetValueFromJni             = getValue,
-						CreateLocalRef              = createLRef,
-						CreateMarshalCollection     = createObj,
-						CleanupMarshalCollection    = cleanup,
-					};
+
+					return (JniValueMarshaler) Activator.CreateInstance (typeof (JavaObjectArray<>.ValueMarshaler).MakeGenericType (elementType));
 				}
 
-				if (typeof (IJavaPeerable).GetTypeInfo ().IsAssignableFrom (type.GetTypeInfo ())) {
-					return DefaultObjectMarshaler;
+				if (typeof (IJavaPeerable).GetTypeInfo ().IsAssignableFrom (info)) {
+					return JavaPeerableValueMarshaler.Instance;
 				}
-				return new JniMarshalInfo ();
+				return GetValueMarshalerCore (type);
+			}
+
+			protected virtual JniValueMarshaler GetValueMarshalerCore (Type type)
+			{
+				return ProxyValueMarshaler.Instance;
 			}
 
 			static TDelegate CreateMethodDelegate<TDelegate>(Type type, string methodName)
@@ -405,11 +468,118 @@ static TDelegate CreateMethodDelegate<TDelegate>(Type type, string methodName)
 			{
 				return (TDelegate) (object) type.GetTypeInfo ().GetDeclaredMethod (methodName).CreateDelegate (typeof (TDelegate));
 			}
+		}
+	}
 
-			static readonly JniMarshalInfo DefaultObjectMarshaler = new JniMarshalInfo {
-				GetValueFromJni         = JavaPeerableExtensions.GetValue,
-				CreateLocalRef          = JavaPeerableExtensions.CreateLocalRef,
-			};
+	class JavaPeerableValueMarshaler : JniValueMarshaler<IJavaPeerable> {
+
+		internal    static  JavaPeerableValueMarshaler      Instance    = new JavaPeerableValueMarshaler ();
+
+		public override IJavaPeerable CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			return JniEnvironment.Runtime.ValueManager.GetObject (ref reference, options, targetType);
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (IJavaPeerable value, ParameterAttributes synchronize)
+		{
+			if (value == null || !value.PeerReference.IsValid)
+				return new JniValueMarshalerState ();
+			var r   = value.PeerReference.NewLocalRef ();
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (IJavaPeerable value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+
+	class DelegatingValueMarshaler<T> : JniValueMarshaler<T> {
+
+		JniValueMarshaler   ValueMarshaler;
+
+		public DelegatingValueMarshaler (JniValueMarshaler valueMarshaler)
+		{
+			ValueMarshaler  = valueMarshaler;
+		}
+
+		public override T CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			return (T) ValueMarshaler.CreateValue (ref reference, options, targetType ?? typeof (T));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (T value, ParameterAttributes synchronize)
+		{
+			System.Diagnostics.Debug.WriteLine ("# jonp: DelegatingValueMarshaler.CreateGenericObjectReferenceArgumentState: ValueMarshaler={0}; synchronize={1}", ValueMarshaler.GetType (), synchronize);
+			return ValueMarshaler.CreateObjectReferenceArgumentState (value, synchronize);
+		}
+
+		public override void DestroyGenericArgumentState (T value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			ValueMarshaler.DestroyArgumentState (value, ref state, synchronize);
+		}
+	}
+
+	class ProxyValueMarshaler : JniValueMarshaler<object> {
+
+		internal    static  ProxyValueMarshaler     Instance    = new ProxyValueMarshaler ();
+
+		public override object CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			var jvm     = JniEnvironment.Runtime;
+
+			if (targetType == null || targetType == typeof (object)) {
+				var signature   = jvm.TypeManager.GetTypeSignature (JniEnvironment.Types.GetJniTypeNameFromInstance (reference));
+				targetType      = jvm.TypeManager.GetType (signature);
+			}
+			if (targetType != null) {
+				var vm  = jvm.ValueManager.GetValueMarshaler (targetType);
+				if (vm != Instance) {
+					return vm.CreateValue (ref reference, options, targetType);
+				}
+			}
+
+			var target  = jvm.ValueManager.PeekObject (reference);
+
+			JniObjectReference.Dispose (ref reference, options);
+
+			var proxy   = target as JavaProxyObject;
+			if (proxy != null) {
+				JniObjectReference.Dispose (ref reference, options);
+				return proxy.Value;
+			}
+			return null;
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (object value, ParameterAttributes synchronize)
+		{
+			if (value == null)
+				return new JniValueMarshalerState ();
+
+			var jvm     = JniEnvironment.Runtime;
+
+			var vm      = jvm.ValueManager.GetValueMarshaler (value.GetType ());
+			if (vm != Instance) {
+				var s   = vm.CreateObjectReferenceArgumentState (value, synchronize);
+				return new JniValueMarshalerState (s, vm);
+			}
+
+			var p   = JavaProxyObject.GetProxy (value);
+			return new JniValueMarshalerState (p.PeerReference.NewLocalRef ());
+		}
+
+		public override void DestroyGenericArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var vm  = state.Extra as JniValueMarshaler;
+			if (vm != null) {
+				vm.DestroyArgumentState (value, ref state, synchronize);
+				return;
+			}
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state = new JniValueMarshalerState ();
 		}
 	}
 
diff --git a/src/Java.Interop/Java.Interop/JniStringValueMarshaler.cs b/src/Java.Interop/Java.Interop/JniStringValueMarshaler.cs
new file mode 100644
index 000000000..4993e68c5
--- /dev/null
+++ b/src/Java.Interop/Java.Interop/JniStringValueMarshaler.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Java.Interop {
+
+	class JniStringValueMarshaler : JniValueMarshaler<string> {
+
+		internal    static  readonly    JniStringValueMarshaler     Instance    = new JniStringValueMarshaler ();
+
+		public override string CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		{
+			return JniEnvironment.Strings.ToString (ref reference, options, targetType ?? typeof (string));
+		}
+
+		public override JniValueMarshalerState CreateGenericObjectReferenceArgumentState (string value, ParameterAttributes synchronize)
+		{
+			var r   = JniEnvironment.Strings.NewString (value);
+			return new JniValueMarshalerState (r);
+		}
+
+		public override void DestroyGenericArgumentState (string value, ref JniValueMarshalerState state, ParameterAttributes synchronize)
+		{
+			var r   = state.ReferenceValue;
+			JniObjectReference.Dispose (ref r);
+			state   = new JniValueMarshalerState ();
+		}
+	}
+}
diff --git a/src/Java.Interop/Java.Interop/JniValueMarshaler.cs b/src/Java.Interop/Java.Interop/JniValueMarshaler.cs
new file mode 100644
index 000000000..26cf12dfa
--- /dev/null
+++ b/src/Java.Interop/Java.Interop/JniValueMarshaler.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Java.Interop {
+
+	public struct JniValueMarshalerState : IEquatable<JniValueMarshalerState> {
+
+		public  JniArgumentValue        JniArgumentValue    {get; private set;}
+		public  JniObjectReference      ReferenceValue      {get; private set;}
+		public  IJavaPeerable           PeerableValue       {get; private set;}
+		public  object                  Extra               {get; private set;}
+
+		public JniValueMarshalerState (JniArgumentValue jniArgumentValue, object extra = null)
+		{
+			JniArgumentValue    = jniArgumentValue;
+			ReferenceValue      = default (JniObjectReference);
+			PeerableValue       = null;
+			Extra               = extra;
+		}
+
+		public JniValueMarshalerState (JniObjectReference referenceValue, object extra = null)
+		{
+			JniArgumentValue    = new JniArgumentValue (referenceValue);
+			ReferenceValue      = referenceValue;
+			PeerableValue       = null;
+			Extra               = extra;
+		}
+
+		public JniValueMarshalerState (IJavaPeerable peerableValue, object extra = null)
+		{
+			PeerableValue       = peerableValue;
+			ReferenceValue      = peerableValue == null ? default (JniObjectReference) : peerableValue.PeerReference;
+			JniArgumentValue    = new JniArgumentValue (ReferenceValue);
+			Extra               = extra;
+		}
+
+		internal JniValueMarshalerState (JniValueMarshalerState copy, object extra = null)
+		{
+			JniArgumentValue    = copy.JniArgumentValue;
+			ReferenceValue      = copy.ReferenceValue;
+			PeerableValue       = copy.PeerableValue;
+			Extra               = extra ?? copy.Extra;
+		}
+
+		public override int GetHashCode ()
+		{
+			return JniArgumentValue.GetHashCode ();
+		}
+
+		public override bool Equals (object obj)
+		{
+			var o = obj as JniValueMarshalerState?;
+			if (!o.HasValue)
+				return false;
+			return Equals (o.Value);
+		}
+
+		public bool Equals (JniValueMarshalerState value)
+		{
+			return JniArgumentValue.Equals (value.JniArgumentValue) &&
+				ReferenceValue.Equals (value.ReferenceValue) &&
+				object.ReferenceEquals (PeerableValue, value.PeerableValue) &&
+				object.ReferenceEquals (Extra, value.Extra);
+		}
+
+		public override string ToString ()
+		{
+			return string.Format ("JniValueMarshalerState({0}, ReferenceValue={1}, PeerableValue=0x{2}, Extra={3})",
+					JniArgumentValue.ToString (),
+					ReferenceValue.ToString (),
+					RuntimeHelpers.GetHashCode (PeerableValue).ToString ("x"),
+					Extra);
+		}
+	}
+
+	public abstract class JniValueMarshaler {
+
+		public  virtual     bool                    IsJniValueType {
+			get {return false;}
+		}
+
+		public  abstract    object                  CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null);
+
+		public  virtual     JniValueMarshalerState  CreateArgumentState (object value, ParameterAttributes synchronize = 0)
+		{
+			return CreateObjectReferenceArgumentState (value, synchronize);
+		}
+
+		public  abstract    JniValueMarshalerState  CreateObjectReferenceArgumentState (object value, ParameterAttributes synchronize = 0);
+		public  abstract    void                    DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0);
+	}
+
+	public abstract class JniValueMarshaler<T> : JniValueMarshaler {
+
+		public  abstract    T                       CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null);
+
+		public  virtual     JniValueMarshalerState  CreateGenericArgumentState (T value, ParameterAttributes synchronize = 0)
+		{
+			return CreateGenericObjectReferenceArgumentState (value, synchronize);
+		}
+
+		public  abstract    JniValueMarshalerState  CreateGenericObjectReferenceArgumentState (T value, ParameterAttributes synchronize = 0);
+		public  abstract    void                    DestroyGenericArgumentState (T value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0);
+
+		public override object CreateValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType = null)
+		{
+			return CreateGenericValue (ref reference, options, targetType ?? typeof (T));
+		}
+
+		public override JniValueMarshalerState CreateArgumentState (object value, ParameterAttributes synchronize = 0)
+		{
+			return CreateGenericArgumentState ((T) value, synchronize);
+		}
+
+		public override JniValueMarshalerState CreateObjectReferenceArgumentState (object value, ParameterAttributes synchronize = 0)
+		{
+			return CreateGenericObjectReferenceArgumentState ((T) value, synchronize);
+		}
+
+		public override void DestroyArgumentState (object value, ref JniValueMarshalerState state, ParameterAttributes synchronize = 0)
+		{
+			DestroyGenericArgumentState ((T) value, ref state, synchronize);
+		}
+	}
+}
diff --git a/src/Java.Interop/Tests/Interop-Tests.projitems b/src/Java.Interop/Tests/Interop-Tests.projitems
index 2a6d30d07..3551447c8 100644
--- a/src/Java.Interop/Tests/Interop-Tests.projitems
+++ b/src/Java.Interop/Tests/Interop-Tests.projitems
@@ -49,6 +49,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Java.Interop\JniTypeSignatureAttributeTest.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Java.Interop\JniRuntimeTest.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Java.Interop\JniTypeManagerTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Java.Interop\JniValueMarshalerContractTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <JavaInteropTestJar Include="$(MSBuildThisFileDirectory)java\com\xamarin\interop\CallNonvirtualBase.java" />
diff --git a/src/Java.Interop/Tests/Java.Interop/JniRuntimeTest.cs b/src/Java.Interop/Tests/Java.Interop/JniRuntimeTest.cs
index 7d6de6819..e0af9e194 100644
--- a/src/Java.Interop/Tests/Java.Interop/JniRuntimeTest.cs
+++ b/src/Java.Interop/Tests/Java.Interop/JniRuntimeTest.cs
@@ -111,123 +111,6 @@ public unsafe void GetObject_FindBestMatchType ()
 				}
 			}
 		}
-
-		[Test]
-		public void GetJniMarshalInfoForType ()
-		{
-			// not yet implemented...
-			// TODO: but should we default to using JavaProxyObject, instead of special-casing in JniMarshal?
-			//       Probably not? Means that JavaVM.GetJniTypeInfoForType() subclasses can't "just" check for
-			//       null values, but maybe they shouldn't anyway?
-			AssertGetJniMarshalInfoForType (typeof (AppDomain));
-
-			AssertGetJniMarshalInfoForPrimitiveType<bool> ("JniBoolean");
-			AssertGetJniMarshalInfoForPrimitiveType<char> ("JniCharacter");
-			AssertGetJniMarshalInfoForPrimitiveType<short> ("JniShort");
-			AssertGetJniMarshalInfoForPrimitiveType<int> ("JniInteger");
-			AssertGetJniMarshalInfoForPrimitiveType<long> ("JniLong");
-			AssertGetJniMarshalInfoForPrimitiveType<float> ("JniFloat");
-			AssertGetJniMarshalInfoForPrimitiveType<double> ("JniDouble");
-
-			AssertGetJniMarshalInfoForType (typeof (string),
-					getValue:                   "Strings.ToString",
-					createLocalRef:             "Strings.NewString");
-
-			AssertGetJniMarshalInfoForType (typeof (JavaObject),
-					getValue:                   "JavaPeerableExtensions.GetValue",
-					createLocalRef:             "JavaPeerableExtensions.CreateLocalRef");
-			AssertGetJniMarshalInfoForType (typeof (JavaException),
-					getValue:                   "JavaPeerableExtensions.GetValue",
-					createLocalRef:             "JavaPeerableExtensions.CreateLocalRef");
-
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaBooleanArray, bool> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaSByteArray, sbyte> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaCharArray, char> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaInt16Array, short> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaInt32Array, int> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaInt64Array, long> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaSingleArray, float> ();
-			AssertGetJniMarshalInfoForPrimitiveArray<JavaDoubleArray, double> ();
-
-			AssertGetJniMarshalInfoForType (typeof (JavaObjectArray<int>),
-					getValue:                   "JavaObjectArray`1.GetValue",
-					createLocalRef:             "JavaObjectArray`1.CreateLocalRef",
-					createMarshalCollection:    "JavaObjectArray`1.CreateMarshalCollection",
-					cleanupMarshalCollection:   "JavaObjectArray`1.CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (JavaObjectArray<int[]>),
-					getValue:                   "JavaObjectArray`1.GetValue",
-					createLocalRef:             "JavaObjectArray`1.CreateLocalRef",
-					createMarshalCollection:    "JavaObjectArray`1.CreateMarshalCollection",
-					cleanupMarshalCollection:   "JavaObjectArray`1.CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (JavaObjectArray<int[][]>),
-					getValue:                   "JavaObjectArray`1.GetValue",
-					createLocalRef:             "JavaObjectArray`1.CreateLocalRef",
-					createMarshalCollection:    "JavaObjectArray`1.CreateMarshalCollection",
-					cleanupMarshalCollection:   "JavaObjectArray`1.CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (JavaObjectArray<JavaInt32Array>),
-					getValue:                   "JavaObjectArray`1.GetValue",
-					createLocalRef:             "JavaObjectArray`1.CreateLocalRef",
-					createMarshalCollection:    "JavaObjectArray`1.CreateMarshalCollection",
-					cleanupMarshalCollection:   "JavaObjectArray`1.CleanupMarshalCollection");
-		}
-
-		static void AssertGetJniMarshalInfoForType (Type type, string getValue = null, string createJValue = null, string createLocalRef = null, string createMarshalCollection = null, string cleanupMarshalCollection = null)
-		{
-			Action<string, Delegate, string> assertMethod = (expected, target, message) => {
-				if (expected == null)
-					Assert.IsNull (target, message);
-				else {
-					var m = target.Method;
-					Assert.AreEqual (
-							expected,
-							string.Format ("{0}.{1}", m.DeclaringType.Name, m.Name),
-							message);
-				}
-			};
-			var info = JniRuntime.CurrentRuntime.ValueManager.GetJniMarshalInfoForType (type);
-			assertMethod (getValue,                 info.GetValueFromJni,           "GetValueFromJni");
-			assertMethod (createJValue,             info.CreateJniArgumentValue,    "CreateJniArgumentValue");
-			assertMethod (createLocalRef,           info.CreateLocalRef,            "CreateLocalRef");
-			assertMethod (createMarshalCollection,  info.CreateMarshalCollection,   "CreateMarshalCollection");
-			assertMethod (cleanupMarshalCollection, info.CleanupMarshalCollection,  "CleanupMarshalCollection");
-		}
-
-		static void AssertGetJniMarshalInfoForPrimitiveType<T> (string type)
-		{
-			AssertGetJniMarshalInfoForType (typeof (T),
-					getValue:       type + ".GetValueFromJni",
-					createJValue:   type + ".CreateJniArgumentValue",
-					createLocalRef: type + ".CreateLocalRef");
-			var info = JniRuntime.CurrentRuntime.ValueManager.GetJniMarshalInfoForType (typeof(T));
-			info.CreateJniArgumentValue (default (T));
-			var lref = info.CreateLocalRef (default (T));
-			Assert.AreEqual (default (T), info.GetValueFromJni (ref lref, JniObjectReferenceOptions.Copy, null));
-			JniObjectReference.Dispose (ref lref);
-		}
-
-		static void AssertGetJniMarshalInfoForPrimitiveArray<TArray, TElement> ()
-		{
-			AssertGetJniMarshalInfoForType (typeof (TElement[]),
-					getValue:                   typeof (TArray).Name + ".GetValueFromJni",
-					createLocalRef:             typeof (TArray).Name + ".CreateLocalRef",
-					createMarshalCollection:    typeof (TArray).Name + ".CreateMarshalCollection",
-					cleanupMarshalCollection:   typeof (TArray).Name + ".CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (JavaArray<TElement>),
-					getValue:                   typeof (TArray).Name + ".GetValueFromJni",
-					createLocalRef:             typeof (TArray).Name + ".CreateLocalRef",
-					createMarshalCollection:    typeof (TArray).Name + ".CreateMarshalCollection",
-					cleanupMarshalCollection:   typeof (TArray).Name + ".CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (JavaPrimitiveArray<TElement>),
-					getValue:                   typeof (TArray).Name + ".GetValueFromJni",
-					createLocalRef:             typeof (TArray).Name + ".CreateLocalRef",
-					createMarshalCollection:    typeof (TArray).Name + ".CreateMarshalCollection",
-					cleanupMarshalCollection:   typeof (TArray).Name + ".CleanupMarshalCollection");
-			AssertGetJniMarshalInfoForType (typeof (TArray),
-					getValue:                   typeof (TArray).Name + ".GetValueFromJni",
-					createLocalRef:             typeof (TArray).Name + ".CreateLocalRef",
-					createMarshalCollection:    typeof (TArray).Name + ".CreateMarshalCollection",
-					cleanupMarshalCollection:   typeof (TArray).Name + ".CleanupMarshalCollection");
-		}
 	}
 }
 
diff --git a/src/Java.Interop/Tests/Java.Interop/JniValueMarshalerContractTests.cs b/src/Java.Interop/Tests/Java.Interop/JniValueMarshalerContractTests.cs
new file mode 100644
index 000000000..209f29579
--- /dev/null
+++ b/src/Java.Interop/Tests/Java.Interop/JniValueMarshalerContractTests.cs
@@ -0,0 +1,412 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using Java.Interop;
+
+using NUnit.Framework;
+
+namespace Java.InteropTests {
+
+	public abstract class JniValueMarshalerContractTests<T> : JavaVMFixture {
+
+		protected   abstract    T       Value           {get;}
+
+		protected   virtual     bool    IsJniValueType  {get;}
+
+		protected   virtual     bool    Equals (T x, T y)
+		{
+			return EqualityComparer<T>.Default.Equals (x, y);
+		}
+
+		protected   virtual     void    Dispose (T value)
+		{
+		}
+
+		protected   JniValueMarshaler<T>    marshaler;
+
+		protected JniValueMarshalerContractTests (JniValueMarshaler<T> marshaler = null)
+		{
+			this.marshaler  = marshaler ?? JniRuntime.CurrentRuntime.ValueManager.GetValueMarshaler<T> ();
+		}
+
+		[Test]
+		public void TestIsJniValueType ()
+		{
+			Assert.AreEqual (IsJniValueType, marshaler.IsJniValueType);
+		}
+
+		[Test]
+		public void CreateArgumentState ()
+		{
+			if (IsJniValueType) {
+				var s   = marshaler.CreateArgumentState (Value);
+
+				// Note: Only valid if `Value` isn't 0, so don't do that!
+				Assert.AreNotEqual (new JniArgumentValue (), s.JniArgumentValue);
+
+				// JniValueMarshaler<T>.CreateArgumentState() for value types only
+				// fills out the JniArgumentValue value, nothing else.
+				Assert.IsFalse (s.ReferenceValue.IsValid);
+				Assert.IsNull (s.PeerableValue);
+				Assert.IsNull (s.Extra);
+
+				marshaler.DestroyArgumentState (Value, ref s);
+				Assert.AreEqual (new JniValueMarshalerState (), s);
+			}
+			else {
+				var s   = marshaler.CreateArgumentState (Value);
+
+				if (s.PeerableValue != null) {
+					Assert.AreEqual (s.PeerableValue.PeerReference, s.ReferenceValue);
+				}
+				Assert.IsTrue (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+
+				marshaler.DestroyArgumentState (Value, ref s);
+				Assert.AreEqual (new JniValueMarshalerState (), s);
+			}
+		}
+
+		[Test]
+		public void CreateGenericArgumentState ()
+		{
+			if (IsJniValueType) {
+				var s   = marshaler.CreateGenericArgumentState (Value);
+
+				// Note: Only valid if `Value` isn't 0, so don't do that!
+				Assert.AreNotEqual (new JniArgumentValue (), s.JniArgumentValue);
+
+				// JniValueMarshaler<T>.CreateArgumentState() for value types only
+				// fills out the JniArgumentValue value, nothing else.
+				Assert.IsFalse (s.ReferenceValue.IsValid);
+				Assert.IsNull (s.PeerableValue);
+				Assert.IsNull (s.Extra);
+
+				marshaler.DestroyGenericArgumentState (Value, ref s);
+				Assert.AreEqual (new JniValueMarshalerState (), s);
+			}
+			else {
+				var s   = marshaler.CreateGenericArgumentState (Value);
+
+				if (s.PeerableValue != null) {
+					Assert.AreEqual (s.PeerableValue.PeerReference, s.ReferenceValue);
+				}
+				Assert.IsTrue (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+
+				marshaler.DestroyGenericArgumentState (Value, ref s);
+				Assert.AreEqual (new JniValueMarshalerState (), s);
+			}
+		}
+
+		[Test]
+		public void CreateObjectReferenceArgumentState_DefaultValue ()
+		{
+			var s = marshaler.CreateObjectReferenceArgumentState (default (T));
+
+			if (IsJniValueType) {
+				Assert.IsTrue (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+			} else {
+				Assert.IsFalse (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (), s.JniArgumentValue);
+			}
+			Assert.IsNull (s.PeerableValue);
+			marshaler.DestroyArgumentState (default (T), ref s);
+			Assert.AreEqual (new JniValueMarshalerState (), s);
+		}
+
+		[Test]
+		public void CreateObjectReferenceArgumentState ()
+		{
+			var s   = marshaler.CreateObjectReferenceArgumentState (Value);
+			if (s.PeerableValue != null) {
+				Assert.AreEqual (s.PeerableValue.PeerReference, s.ReferenceValue);
+			}
+			Assert.IsTrue (s.ReferenceValue.IsValid);
+			Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+
+			marshaler.DestroyArgumentState (Value, ref s);
+			Assert.AreEqual (new JniValueMarshalerState (), s);
+		}
+
+		[Test]
+		public void CreateGenericObjectReferenceArgumentState_DefaultValue ()
+		{
+			var s = marshaler.CreateGenericObjectReferenceArgumentState (default (T));
+
+			if (IsJniValueType) {
+				Assert.IsTrue (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+			} else {
+				Assert.IsFalse (s.ReferenceValue.IsValid);
+				Assert.AreEqual (new JniArgumentValue (), s.JniArgumentValue);
+			}
+			Assert.IsNull (s.PeerableValue);
+			marshaler.DestroyGenericArgumentState (default (T), ref s);
+			Assert.AreEqual (new JniValueMarshalerState (), s);
+		}
+
+		[Test]
+		public void CreateGenericObjectReferenceArgumentState ()
+		{
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (Value);
+			if (s.PeerableValue != null) {
+				Assert.AreEqual (s.PeerableValue.PeerReference, s.ReferenceValue);
+			}
+			Assert.IsTrue (s.ReferenceValue.IsValid);
+			Assert.AreEqual (new JniArgumentValue (s.ReferenceValue), s.JniArgumentValue);
+
+			marshaler.DestroyGenericArgumentState (Value, ref s);
+			Assert.AreEqual (new JniValueMarshalerState (), s);
+		}
+
+		[Test]
+		public void CreateValue ()
+		{
+			var s   = marshaler.CreateObjectReferenceArgumentState (Value);
+			var r   = s.ReferenceValue;
+			var o   = marshaler.CreateValue (ref r, JniObjectReferenceOptions.Copy);
+			Assert.IsTrue (Equals (Value, (T) o));
+			marshaler.DestroyArgumentState (Value, ref s);
+
+			Dispose ((T) o);
+		}
+
+		[Test]
+		public void CreateGenericValue ()
+		{
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (Value);
+			var r   = s.ReferenceValue;
+			var o   = marshaler.CreateGenericValue (ref r, JniObjectReferenceOptions.Copy);
+			Assert.IsTrue (Equals (Value, o));
+			marshaler.DestroyGenericArgumentState (Value, ref s);
+
+			Dispose (o);
+		}
+
+		[Test]
+		public void DestroyArgumentState ()
+		{
+			var s   = new JniValueMarshalerState ();
+			marshaler.DestroyArgumentState (null, ref s);
+		}
+
+		[Test]
+		public void DestroyGenericArgumentState ()
+		{
+			var s   = new JniValueMarshalerState ();
+			marshaler.DestroyGenericArgumentState (default (T), ref s);
+		}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_String_ContractTests : JniValueMarshalerContractTests<string> {
+		protected   override    string      Value       {get {return "value";}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Boolean_ContractTests : JniValueMarshalerContractTests<bool> {
+		protected   override    bool    Value           {get {return true;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_SByte_ContractTests : JniValueMarshalerContractTests<sbyte> {
+		protected   override    sbyte   Value           {get {return (sbyte) 2;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Char_ContractTests : JniValueMarshalerContractTests<char> {
+		protected   override    char    Value           {get {return '3';}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Int16_ContractTests : JniValueMarshalerContractTests<short> {
+		protected   override    short   Value           {get {return (short) 4;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Int32_ContractTests : JniValueMarshalerContractTests<int> {
+		protected   override    int     Value           {get {return 5;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Int64_ContractTests : JniValueMarshalerContractTests<long> {
+		protected   override    long    Value           {get {return 6;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Single_ContractTests : JniValueMarshalerContractTests<float> {
+		protected   override    float   Value           {get {return 7F;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Double_ContractTests : JniValueMarshalerContractTests<double> {
+		protected   override    double  Value           {get {return 8D;}}
+		protected   override    bool    IsJniValueType  {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableBoolean_ContractTests : JniValueMarshalerContractTests<bool?> {
+		protected   override    bool?   Value           {get {return true;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableSByte_ContractTests : JniValueMarshalerContractTests<sbyte?> {
+		protected   override    sbyte?  Value           {get {return (sbyte) 2;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableChar_ContractTests : JniValueMarshalerContractTests<char?> {
+		protected   override    char?   Value           {get {return '3';}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableInt16_ContractTests : JniValueMarshalerContractTests<short?> {
+		protected   override    short?  Value           {get {return (short) 4;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableInt32_ContractTests : JniValueMarshalerContractTests<int?> {
+		protected   override    int?    Value           {get {return 5;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableInt64_ContractTests : JniValueMarshalerContractTests<long?> {
+		protected   override    long?   Value           {get {return 6;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableSingle_ContractTests : JniValueMarshalerContractTests<float?> {
+		protected   override    float?  Value           {get {return 7F;}}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_NullableDouble_ContractTests : JniValueMarshalerContractTests<double?> {
+		protected   override    double? Value           {get {return 8D;}}
+	}
+
+	public abstract class JniInt32ArrayValueMarshalerContractTests<T> : JniValueMarshalerContractTests<T>
+		where T : IEnumerable<int>
+	{
+		protected   abstract    T       CreateArray (int[] values);
+
+		protected   override    T       Value {
+			get {return CreateArray (new[]{ 1, 2, 3 });}
+		}
+
+		protected   override    bool    Equals (T x, T y)
+		{
+			return x.SequenceEqual (y);
+		}
+
+		[Test]
+		public unsafe void DestroyGenericArgumentState_UpdatesSource ()
+		{
+			var a   = CreateArray (new[]{ 1 });
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (a);
+			fixed (int *p = new[]{3})
+				JniEnvironment.Arrays.SetIntArrayRegion (s.ReferenceValue, 0, 1, p);
+			marshaler.DestroyGenericArgumentState (a, ref s);
+			Assert.AreEqual (3, a.First ());
+			Dispose (a);
+		}
+
+		protected override void Dispose (T value)
+		{
+			var d = value as IDisposable;
+			if (d != null) {
+				d.Dispose ();
+			}
+		}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_Int32Array_ContractTests : JniInt32ArrayValueMarshalerContractTests<int[]> {
+		protected   override    int[]                   CreateArray (int[] values) {return values;}
+
+		[Test]
+		public unsafe void CreateGenericObjectReferenceArgumentState_OutParameterDoesNotCopy ()
+		{
+			var a   = new[]{ 1 };
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (a, ParameterAttributes.Out);
+			int v;
+			JniEnvironment.Arrays.GetIntArrayRegion (s.ReferenceValue, 0, 1, &v);
+			Assert.AreEqual (0, v);
+			marshaler.DestroyGenericArgumentState (a, ref s);
+		}
+
+		[Test]
+		public unsafe void DestroyGenericArgumentState_InParameterDoesNotUpdatesSource ()
+		{
+			var a   = CreateArray (new[]{ 1 });
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (a);
+			fixed (int *p = new[]{3})
+				JniEnvironment.Arrays.SetIntArrayRegion (s.ReferenceValue, 0, 1, p);
+			marshaler.DestroyGenericArgumentState (a, ref s, ParameterAttributes.In);
+			Assert.AreEqual (1, a.First ());
+			Dispose (a);
+		}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_ListOfInt32_ContractTests : JniInt32ArrayValueMarshalerContractTests<IList<int>> {
+		protected   override    IList<int>              CreateArray (int[] values) {return values;}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_JavaArray_Int32_ContractTests : JniInt32ArrayValueMarshalerContractTests<JavaArray<int>> {
+		protected   override    JavaArray<int>          CreateArray (int[] values) {return new JavaInt32Array (values);}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_JavaPrimitiveArray_Int32_ContractTests : JniInt32ArrayValueMarshalerContractTests<JavaPrimitiveArray<int>> {
+		protected   override    JavaPrimitiveArray<int> CreateArray (int[] values) {return new JavaInt32Array (values);}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_JavaInt32Array_ContractTests : JniInt32ArrayValueMarshalerContractTests<JavaInt32Array> {
+		protected   override    JavaInt32Array          CreateArray (int[] values) {return new JavaInt32Array (values);}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_object_ContractTests : JniValueMarshalerContractTests<object> {
+
+		readonly    object      value   = new object ();
+
+		protected   override    object                  Value               {get {return value;}}
+
+		[Test]
+		public void SpecificTypesAreUsed ()
+		{
+			// As a "GREF optimization", the JniValueMarshaler<object> implementation
+			// will use a "nested" JniValueMarshaler for the runtime type,
+			// e.g. a boxed int will use JniValueMarshaler<int>
+			var s   = marshaler.CreateGenericObjectReferenceArgumentState (42);
+			Assert.AreEqual ("java/lang/Integer",   JniEnvironment.Types.GetJniTypeNameFromInstance (s.ReferenceValue));
+			marshaler.DestroyGenericArgumentState (42, ref s);
+
+			// Compare to the default proxy behavior...
+			s       = marshaler.CreateGenericObjectReferenceArgumentState (value);
+			Assert.AreEqual ("com/xamarin/android/internal/JavaProxyObject",    JniEnvironment.Types.GetJniTypeNameFromInstance (s.ReferenceValue));
+			marshaler.DestroyGenericArgumentState (value, ref s);
+		}
+	}
+
+	[TestFixture]
+	public class JniValueMarshaler_IJavaPeerable_ContractTests : JniValueMarshalerContractTests<IJavaPeerable> {
+		readonly    IJavaPeerable      value   = new JavaObject ();
+
+		protected   override    IJavaPeerable       Value   {get {return value;}}
+	}
+}
+