/*-
 * #%L
 * Java implementation of the SciJava Ops matching engine.
 * %%
 * Copyright (C) 2016 - 2024 SciJava developers.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * #L%
 */
/*
 * This is autogenerated source code -- DO NOT EDIT. Instead, edit the
 * corresponding template in templates/ and rerun bin/generate.groovy.
 */

package org.scijava.ops.engine.matcher.impl;

import java.util.function.BiFunction;
import java.util.function.Function;

import org.scijava.function.Computers;
import org.scijava.function.Container;
import org.scijava.function.Functions;
import org.scijava.function.Inplaces;
import org.scijava.function.Producer;
import org.scijava.ops.api.OpEnvironment;
import org.scijava.ops.api.OpInstance;
import org.scijava.ops.api.RichOp;
import org.scijava.ops.engine.OpWrapper;
import org.scijava.ops.engine.MatchingConditions;

public class OpWrappers {

	// -- producer --

	public static class ProducerOpWrapper<T> implements OpWrapper<Producer<T>> {

		@Override
		public RichOp<Producer<T>> wrap( //
            final OpInstance<Producer<T>> instance, //
            final OpEnvironment env, //
            final MatchingConditions conditions)
		{
			class GenericTypedProducer //
				extends AbstractRichOp<Producer<T>> //
				implements Producer<T>
			{

				public GenericTypedProducer()
				{
					super(instance, env, conditions);
				}

				@Override
				public T create() {
					preprocess();

					// Call the op
					var out = instance.op().create();

					postprocess(out);

					return out;
				}

				@Override
				public Producer<T> asOpType() {
					return this;
				}

			}
			return new GenericTypedProducer();
		}
	}

	// -- functions --

	public static class Function1OpWrapper<I, O> //
		implements //
		OpWrapper<Function<I, O>>
	{

		@Override
		public RichOp<Function<I, O>> wrap( //
			final OpInstance<Function<I, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction1 //
				extends AbstractRichOp<Function<I, O>> //
				implements Function<I, O> 
			{

				public GenericTypedFunction1()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I in) //
				{
					preprocess(in);

					// Call the op
					var out = instance.op().apply(in);

					postprocess(out);
					return out;
				}

				@Override
				public Function<I, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction1();
		}
	}

	public static class Function2OpWrapper<I1, I2, O> //
		implements //
		OpWrapper<BiFunction<I1, I2, O>>
	{

		@Override
		public RichOp<BiFunction<I1, I2, O>> wrap( //
			final OpInstance<BiFunction<I1, I2, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction2 //
				extends AbstractRichOp<BiFunction<I1, I2, O>> //
				implements BiFunction<I1, I2, O> 
			{

				public GenericTypedFunction2()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2) //
				{
					preprocess(in1, in2);

					// Call the op
					var out = instance.op().apply(in1, in2);

					postprocess(out);
					return out;
				}

				@Override
				public BiFunction<I1, I2, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction2();
		}
	}

	public static class Function3OpWrapper<I1, I2, I3, O> //
		implements //
		OpWrapper<Functions.Arity3<I1, I2, I3, O>>
	{

		@Override
		public RichOp<Functions.Arity3<I1, I2, I3, O>> wrap( //
			final OpInstance<Functions.Arity3<I1, I2, I3, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction3 //
				extends AbstractRichOp<Functions.Arity3<I1, I2, I3, O>> //
				implements Functions.Arity3<I1, I2, I3, O> 
			{

				public GenericTypedFunction3()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3) //
				{
					preprocess(in1, in2, in3);

					// Call the op
					var out = instance.op().apply(in1, in2, in3);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity3<I1, I2, I3, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction3();
		}
	}

	public static class Function4OpWrapper<I1, I2, I3, I4, O> //
		implements //
		OpWrapper<Functions.Arity4<I1, I2, I3, I4, O>>
	{

		@Override
		public RichOp<Functions.Arity4<I1, I2, I3, I4, O>> wrap( //
			final OpInstance<Functions.Arity4<I1, I2, I3, I4, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction4 //
				extends AbstractRichOp<Functions.Arity4<I1, I2, I3, I4, O>> //
				implements Functions.Arity4<I1, I2, I3, I4, O> 
			{

				public GenericTypedFunction4()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4) //
				{
					preprocess(in1, in2, in3, in4);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity4<I1, I2, I3, I4, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction4();
		}
	}

	public static class Function5OpWrapper<I1, I2, I3, I4, I5, O> //
		implements //
		OpWrapper<Functions.Arity5<I1, I2, I3, I4, I5, O>>
	{

		@Override
		public RichOp<Functions.Arity5<I1, I2, I3, I4, I5, O>> wrap( //
			final OpInstance<Functions.Arity5<I1, I2, I3, I4, I5, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction5 //
				extends AbstractRichOp<Functions.Arity5<I1, I2, I3, I4, I5, O>> //
				implements Functions.Arity5<I1, I2, I3, I4, I5, O> 
			{

				public GenericTypedFunction5()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5) //
				{
					preprocess(in1, in2, in3, in4, in5);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity5<I1, I2, I3, I4, I5, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction5();
		}
	}

	public static class Function6OpWrapper<I1, I2, I3, I4, I5, I6, O> //
		implements //
		OpWrapper<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>>
	{

		@Override
		public RichOp<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>> wrap( //
			final OpInstance<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction6 //
				extends AbstractRichOp<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>> //
				implements Functions.Arity6<I1, I2, I3, I4, I5, I6, O> 
			{

				public GenericTypedFunction6()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6) //
				{
					preprocess(in1, in2, in3, in4, in5, in6);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity6<I1, I2, I3, I4, I5, I6, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction6();
		}
	}

	public static class Function7OpWrapper<I1, I2, I3, I4, I5, I6, I7, O> //
		implements //
		OpWrapper<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>>
	{

		@Override
		public RichOp<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> wrap( //
			final OpInstance<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction7 //
				extends AbstractRichOp<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> //
				implements Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> 
			{

				public GenericTypedFunction7()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction7();
		}
	}

	public static class Function8OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, O> //
		implements //
		OpWrapper<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>>
	{

		@Override
		public RichOp<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> wrap( //
			final OpInstance<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction8 //
				extends AbstractRichOp<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> //
				implements Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> 
			{

				public GenericTypedFunction8()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction8();
		}
	}

	public static class Function9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> //
		implements //
		OpWrapper<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>>
	{

		@Override
		public RichOp<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> wrap( //
			final OpInstance<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction9 //
				extends AbstractRichOp<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> //
				implements Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> 
			{

				public GenericTypedFunction9()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction9();
		}
	}

	public static class Function10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> //
		implements //
		OpWrapper<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>>
	{

		@Override
		public RichOp<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> wrap( //
			final OpInstance<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction10 //
				extends AbstractRichOp<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> //
				implements Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> 
			{

				public GenericTypedFunction10()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction10();
		}
	}

	public static class Function11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> //
		implements //
		OpWrapper<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>>
	{

		@Override
		public RichOp<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> wrap( //
			final OpInstance<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction11 //
				extends AbstractRichOp<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> //
				implements Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> 
			{

				public GenericTypedFunction11()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction11();
		}
	}

	public static class Function12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> //
		implements //
		OpWrapper<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>>
	{

		@Override
		public RichOp<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> wrap( //
			final OpInstance<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction12 //
				extends AbstractRichOp<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> //
				implements Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> 
			{

				public GenericTypedFunction12()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction12();
		}
	}

	public static class Function13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> //
		implements //
		OpWrapper<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>>
	{

		@Override
		public RichOp<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> wrap( //
			final OpInstance<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction13 //
				extends AbstractRichOp<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> //
				implements Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> 
			{

				public GenericTypedFunction13()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction13();
		}
	}

	public static class Function14OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> //
		implements //
		OpWrapper<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>>
	{

		@Override
		public RichOp<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> wrap( //
			final OpInstance<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction14 //
				extends AbstractRichOp<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> //
				implements Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> 
			{

				public GenericTypedFunction14()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction14();
		}
	}

	public static class Function15OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> //
		implements //
		OpWrapper<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>>
	{

		@Override
		public RichOp<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> wrap( //
			final OpInstance<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction15 //
				extends AbstractRichOp<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> //
				implements Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> 
			{

				public GenericTypedFunction15()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14, I15 in15) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction15();
		}
	}

	public static class Function16OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> //
		implements //
		OpWrapper<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>>
	{

		@Override
		public RichOp<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> wrap( //
			final OpInstance<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedFunction16 //
				extends AbstractRichOp<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> //
				implements Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> 
			{

				public GenericTypedFunction16()
				{
					super(instance, env, conditions);
				}

				@Override
				public O apply(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14, I15 in15, I16 in16) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16);

					// Call the op
					var out = instance.op().apply(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16);

					postprocess(out);
					return out;
				}

				@Override
				public Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedFunction16();
		}
	}

	// -- computers --

	public static class Computer0OpWrapper<O> //
		implements //
		OpWrapper<Computers.Arity0<O>>
	{

		@Override
		public RichOp<Computers.Arity0<O>> wrap( //
			final OpInstance<Computers.Arity0<O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer0 //
				extends AbstractRichOp<Computers.Arity0<O>> //
				implements Computers.Arity0<O> 
			{
				public GenericTypedComputer0()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(@Container O out) //
				{
					preprocess(out);

					// Call the op
					instance.op().compute(out);

					postprocess(out);
				}

				@Override
				public Computers.Arity0<O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer0();
		}
	}

	public static class Computer1OpWrapper<I, O> //
		implements //
		OpWrapper<Computers.Arity1<I, O>>
	{

		@Override
		public RichOp<Computers.Arity1<I, O>> wrap( //
			final OpInstance<Computers.Arity1<I, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer1 //
				extends AbstractRichOp<Computers.Arity1<I, O>> //
				implements Computers.Arity1<I, O> 
			{
				public GenericTypedComputer1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I in, @Container O out) //
				{
					preprocess(in, out);

					// Call the op
					instance.op().compute(in, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity1<I, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer1();
		}
	}

	public static class Computer2OpWrapper<I1, I2, O> //
		implements //
		OpWrapper<Computers.Arity2<I1, I2, O>>
	{

		@Override
		public RichOp<Computers.Arity2<I1, I2, O>> wrap( //
			final OpInstance<Computers.Arity2<I1, I2, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer2 //
				extends AbstractRichOp<Computers.Arity2<I1, I2, O>> //
				implements Computers.Arity2<I1, I2, O> 
			{
				public GenericTypedComputer2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, @Container O out) //
				{
					preprocess(in1, in2, out);

					// Call the op
					instance.op().compute(in1, in2, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity2<I1, I2, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer2();
		}
	}

	public static class Computer3OpWrapper<I1, I2, I3, O> //
		implements //
		OpWrapper<Computers.Arity3<I1, I2, I3, O>>
	{

		@Override
		public RichOp<Computers.Arity3<I1, I2, I3, O>> wrap( //
			final OpInstance<Computers.Arity3<I1, I2, I3, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer3 //
				extends AbstractRichOp<Computers.Arity3<I1, I2, I3, O>> //
				implements Computers.Arity3<I1, I2, I3, O> 
			{
				public GenericTypedComputer3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, @Container O out) //
				{
					preprocess(in1, in2, in3, out);

					// Call the op
					instance.op().compute(in1, in2, in3, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity3<I1, I2, I3, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer3();
		}
	}

	public static class Computer4OpWrapper<I1, I2, I3, I4, O> //
		implements //
		OpWrapper<Computers.Arity4<I1, I2, I3, I4, O>>
	{

		@Override
		public RichOp<Computers.Arity4<I1, I2, I3, I4, O>> wrap( //
			final OpInstance<Computers.Arity4<I1, I2, I3, I4, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer4 //
				extends AbstractRichOp<Computers.Arity4<I1, I2, I3, I4, O>> //
				implements Computers.Arity4<I1, I2, I3, I4, O> 
			{
				public GenericTypedComputer4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity4<I1, I2, I3, I4, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer4();
		}
	}

	public static class Computer5OpWrapper<I1, I2, I3, I4, I5, O> //
		implements //
		OpWrapper<Computers.Arity5<I1, I2, I3, I4, I5, O>>
	{

		@Override
		public RichOp<Computers.Arity5<I1, I2, I3, I4, I5, O>> wrap( //
			final OpInstance<Computers.Arity5<I1, I2, I3, I4, I5, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer5 //
				extends AbstractRichOp<Computers.Arity5<I1, I2, I3, I4, I5, O>> //
				implements Computers.Arity5<I1, I2, I3, I4, I5, O> 
			{
				public GenericTypedComputer5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity5<I1, I2, I3, I4, I5, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer5();
		}
	}

	public static class Computer6OpWrapper<I1, I2, I3, I4, I5, I6, O> //
		implements //
		OpWrapper<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>>
	{

		@Override
		public RichOp<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> wrap( //
			final OpInstance<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer6 //
				extends AbstractRichOp<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> //
				implements Computers.Arity6<I1, I2, I3, I4, I5, I6, O> 
			{
				public GenericTypedComputer6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity6<I1, I2, I3, I4, I5, I6, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer6();
		}
	}

	public static class Computer7OpWrapper<I1, I2, I3, I4, I5, I6, I7, O> //
		implements //
		OpWrapper<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>>
	{

		@Override
		public RichOp<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> wrap( //
			final OpInstance<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer7 //
				extends AbstractRichOp<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> //
				implements Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O> 
			{
				public GenericTypedComputer7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer7();
		}
	}

	public static class Computer8OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, O> //
		implements //
		OpWrapper<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>>
	{

		@Override
		public RichOp<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> wrap( //
			final OpInstance<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer8 //
				extends AbstractRichOp<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> //
				implements Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> 
			{
				public GenericTypedComputer8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer8();
		}
	}

	public static class Computer9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> //
		implements //
		OpWrapper<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>>
	{

		@Override
		public RichOp<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> wrap( //
			final OpInstance<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer9 //
				extends AbstractRichOp<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> //
				implements Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> 
			{
				public GenericTypedComputer9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer9();
		}
	}

	public static class Computer10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> //
		implements //
		OpWrapper<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>>
	{

		@Override
		public RichOp<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> wrap( //
			final OpInstance<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer10 //
				extends AbstractRichOp<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> //
				implements Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> 
			{
				public GenericTypedComputer10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer10();
		}
	}

	public static class Computer11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> //
		implements //
		OpWrapper<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>>
	{

		@Override
		public RichOp<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> wrap( //
			final OpInstance<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer11 //
				extends AbstractRichOp<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> //
				implements Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> 
			{
				public GenericTypedComputer11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer11();
		}
	}

	public static class Computer12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> //
		implements //
		OpWrapper<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>>
	{

		@Override
		public RichOp<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> wrap( //
			final OpInstance<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer12 //
				extends AbstractRichOp<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> //
				implements Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> 
			{
				public GenericTypedComputer12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer12();
		}
	}

	public static class Computer13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> //
		implements //
		OpWrapper<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>>
	{

		@Override
		public RichOp<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> wrap( //
			final OpInstance<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer13 //
				extends AbstractRichOp<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> //
				implements Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> 
			{
				public GenericTypedComputer13()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer13();
		}
	}

	public static class Computer14OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> //
		implements //
		OpWrapper<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>>
	{

		@Override
		public RichOp<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> wrap( //
			final OpInstance<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer14 //
				extends AbstractRichOp<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> //
				implements Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> 
			{
				public GenericTypedComputer14()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer14();
		}
	}

	public static class Computer15OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> //
		implements //
		OpWrapper<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>>
	{

		@Override
		public RichOp<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> wrap( //
			final OpInstance<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer15 //
				extends AbstractRichOp<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> //
				implements Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> 
			{
				public GenericTypedComputer15()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14, I15 in15, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer15();
		}
	}

	public static class Computer16OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> //
		implements //
		OpWrapper<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>>
	{

		@Override
		public RichOp<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> wrap( //
			final OpInstance<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedComputer16 //
				extends AbstractRichOp<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> //
				implements Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> 
			{
				public GenericTypedComputer16()
				{
					super(instance, env, conditions);
				}

				@Override
				public void compute(I1 in1, I2 in2, I3 in3, I4 in4, I5 in5, I6 in6, I7 in7, I8 in8, I9 in9, I10 in10, I11 in11, I12 in12, I13 in13, I14 in14, I15 in15, I16 in16, @Container O out) //
				{
					preprocess(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, out);

					// Call the op
					instance.op().compute(in1, in2, in3, in4, in5, in6, in7, in8, in9, in10, in11, in12, in13, in14, in15, in16, out);

					postprocess(out);
				}

				@Override
				public Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> asOpType() {
					return this;
				}

			}
			return new GenericTypedComputer16();
		}
	}

	// -- inplaces --

	public static class Inplace1OpWrapper<IO> //
		implements //
		OpWrapper<Inplaces.Arity1<IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity1<IO>> wrap( //
			final OpInstance<Inplaces.Arity1<IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace1 //
				extends AbstractRichOp<Inplaces.Arity1<IO>> //
				implements Inplaces.Arity1<IO> 
			{
				public GenericTypedInplace1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType) //
				{
					preprocess(ioType);

					// Call the op
					instance.op().mutate(ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity1<IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace1();
		}
	}

	public static class Inplace2_1OpWrapper<IO, I2> //
		implements //
		OpWrapper<Inplaces.Arity2_1<IO, I2>> //
	{

		@Override
		public RichOp<Inplaces.Arity2_1<IO, I2>> wrap( //
			final OpInstance<Inplaces.Arity2_1<IO, I2>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace2_1 //
				extends AbstractRichOp<Inplaces.Arity2_1<IO, I2>> //
				implements Inplaces.Arity2_1<IO, I2> 
			{
				public GenericTypedInplace2_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type) //
				{
					preprocess(ioType, in2Type);

					// Call the op
					instance.op().mutate(ioType, in2Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity2_1<IO, I2> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace2_1();
		}
	}

	public static class Inplace2_2OpWrapper<I1, IO> //
		implements //
		OpWrapper<Inplaces.Arity2_2<I1, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity2_2<I1, IO>> wrap( //
			final OpInstance<Inplaces.Arity2_2<I1, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace2_2 //
				extends AbstractRichOp<Inplaces.Arity2_2<I1, IO>> //
				implements Inplaces.Arity2_2<I1, IO> 
			{
				public GenericTypedInplace2_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType) //
				{
					preprocess(in1Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity2_2<I1, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace2_2();
		}
	}

	public static class Inplace3_1OpWrapper<IO, I2, I3> //
		implements //
		OpWrapper<Inplaces.Arity3_1<IO, I2, I3>> //
	{

		@Override
		public RichOp<Inplaces.Arity3_1<IO, I2, I3>> wrap( //
			final OpInstance<Inplaces.Arity3_1<IO, I2, I3>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace3_1 //
				extends AbstractRichOp<Inplaces.Arity3_1<IO, I2, I3>> //
				implements Inplaces.Arity3_1<IO, I2, I3> 
			{
				public GenericTypedInplace3_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type) //
				{
					preprocess(ioType, in2Type, in3Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity3_1<IO, I2, I3> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace3_1();
		}
	}

	public static class Inplace3_2OpWrapper<I1, IO, I3> //
		implements //
		OpWrapper<Inplaces.Arity3_2<I1, IO, I3>> //
	{

		@Override
		public RichOp<Inplaces.Arity3_2<I1, IO, I3>> wrap( //
			final OpInstance<Inplaces.Arity3_2<I1, IO, I3>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace3_2 //
				extends AbstractRichOp<Inplaces.Arity3_2<I1, IO, I3>> //
				implements Inplaces.Arity3_2<I1, IO, I3> 
			{
				public GenericTypedInplace3_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type) //
				{
					preprocess(in1Type, ioType, in3Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity3_2<I1, IO, I3> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace3_2();
		}
	}

	public static class Inplace3_3OpWrapper<I1, I2, IO> //
		implements //
		OpWrapper<Inplaces.Arity3_3<I1, I2, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity3_3<I1, I2, IO>> wrap( //
			final OpInstance<Inplaces.Arity3_3<I1, I2, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace3_3 //
				extends AbstractRichOp<Inplaces.Arity3_3<I1, I2, IO>> //
				implements Inplaces.Arity3_3<I1, I2, IO> 
			{
				public GenericTypedInplace3_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity3_3<I1, I2, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace3_3();
		}
	}

	public static class Inplace4_1OpWrapper<IO, I2, I3, I4> //
		implements //
		OpWrapper<Inplaces.Arity4_1<IO, I2, I3, I4>> //
	{

		@Override
		public RichOp<Inplaces.Arity4_1<IO, I2, I3, I4>> wrap( //
			final OpInstance<Inplaces.Arity4_1<IO, I2, I3, I4>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace4_1 //
				extends AbstractRichOp<Inplaces.Arity4_1<IO, I2, I3, I4>> //
				implements Inplaces.Arity4_1<IO, I2, I3, I4> 
			{
				public GenericTypedInplace4_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity4_1<IO, I2, I3, I4> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace4_1();
		}
	}

	public static class Inplace4_2OpWrapper<I1, IO, I3, I4> //
		implements //
		OpWrapper<Inplaces.Arity4_2<I1, IO, I3, I4>> //
	{

		@Override
		public RichOp<Inplaces.Arity4_2<I1, IO, I3, I4>> wrap( //
			final OpInstance<Inplaces.Arity4_2<I1, IO, I3, I4>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace4_2 //
				extends AbstractRichOp<Inplaces.Arity4_2<I1, IO, I3, I4>> //
				implements Inplaces.Arity4_2<I1, IO, I3, I4> 
			{
				public GenericTypedInplace4_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity4_2<I1, IO, I3, I4> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace4_2();
		}
	}

	public static class Inplace4_3OpWrapper<I1, I2, IO, I4> //
		implements //
		OpWrapper<Inplaces.Arity4_3<I1, I2, IO, I4>> //
	{

		@Override
		public RichOp<Inplaces.Arity4_3<I1, I2, IO, I4>> wrap( //
			final OpInstance<Inplaces.Arity4_3<I1, I2, IO, I4>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace4_3 //
				extends AbstractRichOp<Inplaces.Arity4_3<I1, I2, IO, I4>> //
				implements Inplaces.Arity4_3<I1, I2, IO, I4> 
			{
				public GenericTypedInplace4_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity4_3<I1, I2, IO, I4> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace4_3();
		}
	}

	public static class Inplace4_4OpWrapper<I1, I2, I3, IO> //
		implements //
		OpWrapper<Inplaces.Arity4_4<I1, I2, I3, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity4_4<I1, I2, I3, IO>> wrap( //
			final OpInstance<Inplaces.Arity4_4<I1, I2, I3, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace4_4 //
				extends AbstractRichOp<Inplaces.Arity4_4<I1, I2, I3, IO>> //
				implements Inplaces.Arity4_4<I1, I2, I3, IO> 
			{
				public GenericTypedInplace4_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity4_4<I1, I2, I3, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace4_4();
		}
	}

	public static class Inplace5_1OpWrapper<IO, I2, I3, I4, I5> //
		implements //
		OpWrapper<Inplaces.Arity5_1<IO, I2, I3, I4, I5>> //
	{

		@Override
		public RichOp<Inplaces.Arity5_1<IO, I2, I3, I4, I5>> wrap( //
			final OpInstance<Inplaces.Arity5_1<IO, I2, I3, I4, I5>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace5_1 //
				extends AbstractRichOp<Inplaces.Arity5_1<IO, I2, I3, I4, I5>> //
				implements Inplaces.Arity5_1<IO, I2, I3, I4, I5> 
			{
				public GenericTypedInplace5_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity5_1<IO, I2, I3, I4, I5> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace5_1();
		}
	}

	public static class Inplace5_2OpWrapper<I1, IO, I3, I4, I5> //
		implements //
		OpWrapper<Inplaces.Arity5_2<I1, IO, I3, I4, I5>> //
	{

		@Override
		public RichOp<Inplaces.Arity5_2<I1, IO, I3, I4, I5>> wrap( //
			final OpInstance<Inplaces.Arity5_2<I1, IO, I3, I4, I5>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace5_2 //
				extends AbstractRichOp<Inplaces.Arity5_2<I1, IO, I3, I4, I5>> //
				implements Inplaces.Arity5_2<I1, IO, I3, I4, I5> 
			{
				public GenericTypedInplace5_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity5_2<I1, IO, I3, I4, I5> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace5_2();
		}
	}

	public static class Inplace5_3OpWrapper<I1, I2, IO, I4, I5> //
		implements //
		OpWrapper<Inplaces.Arity5_3<I1, I2, IO, I4, I5>> //
	{

		@Override
		public RichOp<Inplaces.Arity5_3<I1, I2, IO, I4, I5>> wrap( //
			final OpInstance<Inplaces.Arity5_3<I1, I2, IO, I4, I5>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace5_3 //
				extends AbstractRichOp<Inplaces.Arity5_3<I1, I2, IO, I4, I5>> //
				implements Inplaces.Arity5_3<I1, I2, IO, I4, I5> 
			{
				public GenericTypedInplace5_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity5_3<I1, I2, IO, I4, I5> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace5_3();
		}
	}

	public static class Inplace5_4OpWrapper<I1, I2, I3, IO, I5> //
		implements //
		OpWrapper<Inplaces.Arity5_4<I1, I2, I3, IO, I5>> //
	{

		@Override
		public RichOp<Inplaces.Arity5_4<I1, I2, I3, IO, I5>> wrap( //
			final OpInstance<Inplaces.Arity5_4<I1, I2, I3, IO, I5>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace5_4 //
				extends AbstractRichOp<Inplaces.Arity5_4<I1, I2, I3, IO, I5>> //
				implements Inplaces.Arity5_4<I1, I2, I3, IO, I5> 
			{
				public GenericTypedInplace5_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity5_4<I1, I2, I3, IO, I5> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace5_4();
		}
	}

	public static class Inplace5_5OpWrapper<I1, I2, I3, I4, IO> //
		implements //
		OpWrapper<Inplaces.Arity5_5<I1, I2, I3, I4, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity5_5<I1, I2, I3, I4, IO>> wrap( //
			final OpInstance<Inplaces.Arity5_5<I1, I2, I3, I4, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace5_5 //
				extends AbstractRichOp<Inplaces.Arity5_5<I1, I2, I3, I4, IO>> //
				implements Inplaces.Arity5_5<I1, I2, I3, I4, IO> 
			{
				public GenericTypedInplace5_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity5_5<I1, I2, I3, I4, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace5_5();
		}
	}

	public static class Inplace6_1OpWrapper<IO, I2, I3, I4, I5, I6> //
		implements //
		OpWrapper<Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6>> wrap( //
			final OpInstance<Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_1 //
				extends AbstractRichOp<Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6>> //
				implements Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6> 
			{
				public GenericTypedInplace6_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_1<IO, I2, I3, I4, I5, I6> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_1();
		}
	}

	public static class Inplace6_2OpWrapper<I1, IO, I3, I4, I5, I6> //
		implements //
		OpWrapper<Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6>> wrap( //
			final OpInstance<Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_2 //
				extends AbstractRichOp<Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6>> //
				implements Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6> 
			{
				public GenericTypedInplace6_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_2<I1, IO, I3, I4, I5, I6> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_2();
		}
	}

	public static class Inplace6_3OpWrapper<I1, I2, IO, I4, I5, I6> //
		implements //
		OpWrapper<Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6>> wrap( //
			final OpInstance<Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_3 //
				extends AbstractRichOp<Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6>> //
				implements Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6> 
			{
				public GenericTypedInplace6_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_3<I1, I2, IO, I4, I5, I6> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_3();
		}
	}

	public static class Inplace6_4OpWrapper<I1, I2, I3, IO, I5, I6> //
		implements //
		OpWrapper<Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6>> wrap( //
			final OpInstance<Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_4 //
				extends AbstractRichOp<Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6>> //
				implements Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6> 
			{
				public GenericTypedInplace6_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_4<I1, I2, I3, IO, I5, I6> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_4();
		}
	}

	public static class Inplace6_5OpWrapper<I1, I2, I3, I4, IO, I6> //
		implements //
		OpWrapper<Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6>> wrap( //
			final OpInstance<Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_5 //
				extends AbstractRichOp<Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6>> //
				implements Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6> 
			{
				public GenericTypedInplace6_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_5<I1, I2, I3, I4, IO, I6> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_5();
		}
	}

	public static class Inplace6_6OpWrapper<I1, I2, I3, I4, I5, IO> //
		implements //
		OpWrapper<Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO>> wrap( //
			final OpInstance<Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace6_6 //
				extends AbstractRichOp<Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO>> //
				implements Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO> 
			{
				public GenericTypedInplace6_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity6_6<I1, I2, I3, I4, I5, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace6_6();
		}
	}

	public static class Inplace7_1OpWrapper<IO, I2, I3, I4, I5, I6, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_1 //
				extends AbstractRichOp<Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7>> //
				implements Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7> 
			{
				public GenericTypedInplace7_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_1<IO, I2, I3, I4, I5, I6, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_1();
		}
	}

	public static class Inplace7_2OpWrapper<I1, IO, I3, I4, I5, I6, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_2 //
				extends AbstractRichOp<Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7>> //
				implements Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7> 
			{
				public GenericTypedInplace7_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_2<I1, IO, I3, I4, I5, I6, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_2();
		}
	}

	public static class Inplace7_3OpWrapper<I1, I2, IO, I4, I5, I6, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_3 //
				extends AbstractRichOp<Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7>> //
				implements Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7> 
			{
				public GenericTypedInplace7_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_3<I1, I2, IO, I4, I5, I6, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_3();
		}
	}

	public static class Inplace7_4OpWrapper<I1, I2, I3, IO, I5, I6, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_4 //
				extends AbstractRichOp<Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7>> //
				implements Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7> 
			{
				public GenericTypedInplace7_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_4<I1, I2, I3, IO, I5, I6, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_4();
		}
	}

	public static class Inplace7_5OpWrapper<I1, I2, I3, I4, IO, I6, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_5 //
				extends AbstractRichOp<Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7>> //
				implements Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7> 
			{
				public GenericTypedInplace7_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_5<I1, I2, I3, I4, IO, I6, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_5();
		}
	}

	public static class Inplace7_6OpWrapper<I1, I2, I3, I4, I5, IO, I7> //
		implements //
		OpWrapper<Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7>> wrap( //
			final OpInstance<Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_6 //
				extends AbstractRichOp<Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7>> //
				implements Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7> 
			{
				public GenericTypedInplace7_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_6<I1, I2, I3, I4, I5, IO, I7> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_6();
		}
	}

	public static class Inplace7_7OpWrapper<I1, I2, I3, I4, I5, I6, IO> //
		implements //
		OpWrapper<Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO>> wrap( //
			final OpInstance<Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace7_7 //
				extends AbstractRichOp<Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO>> //
				implements Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO> 
			{
				public GenericTypedInplace7_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity7_7<I1, I2, I3, I4, I5, I6, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace7_7();
		}
	}

	public static class Inplace8_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_1 //
				extends AbstractRichOp<Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8>> //
				implements Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8> 
			{
				public GenericTypedInplace8_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_1<IO, I2, I3, I4, I5, I6, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_1();
		}
	}

	public static class Inplace8_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_2 //
				extends AbstractRichOp<Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8>> //
				implements Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8> 
			{
				public GenericTypedInplace8_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_2<I1, IO, I3, I4, I5, I6, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_2();
		}
	}

	public static class Inplace8_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_3 //
				extends AbstractRichOp<Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8>> //
				implements Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8> 
			{
				public GenericTypedInplace8_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_3<I1, I2, IO, I4, I5, I6, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_3();
		}
	}

	public static class Inplace8_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_4 //
				extends AbstractRichOp<Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8>> //
				implements Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8> 
			{
				public GenericTypedInplace8_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_4<I1, I2, I3, IO, I5, I6, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_4();
		}
	}

	public static class Inplace8_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_5 //
				extends AbstractRichOp<Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8>> //
				implements Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8> 
			{
				public GenericTypedInplace8_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_5<I1, I2, I3, I4, IO, I6, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_5();
		}
	}

	public static class Inplace8_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_6 //
				extends AbstractRichOp<Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8>> //
				implements Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8> 
			{
				public GenericTypedInplace8_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_6<I1, I2, I3, I4, I5, IO, I7, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_6();
		}
	}

	public static class Inplace8_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8> //
		implements //
		OpWrapper<Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8>> wrap( //
			final OpInstance<Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_7 //
				extends AbstractRichOp<Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8>> //
				implements Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8> 
			{
				public GenericTypedInplace8_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_7<I1, I2, I3, I4, I5, I6, IO, I8> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_7();
		}
	}

	public static class Inplace8_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO> //
		implements //
		OpWrapper<Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO>> wrap( //
			final OpInstance<Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace8_8 //
				extends AbstractRichOp<Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO>> //
				implements Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO> 
			{
				public GenericTypedInplace8_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity8_8<I1, I2, I3, I4, I5, I6, I7, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace8_8();
		}
	}

	public static class Inplace9_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_1 //
				extends AbstractRichOp<Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9>> //
				implements Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9> 
			{
				public GenericTypedInplace9_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_1<IO, I2, I3, I4, I5, I6, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_1();
		}
	}

	public static class Inplace9_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_2 //
				extends AbstractRichOp<Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9>> //
				implements Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9> 
			{
				public GenericTypedInplace9_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_2<I1, IO, I3, I4, I5, I6, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_2();
		}
	}

	public static class Inplace9_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_3 //
				extends AbstractRichOp<Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9>> //
				implements Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9> 
			{
				public GenericTypedInplace9_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_3<I1, I2, IO, I4, I5, I6, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_3();
		}
	}

	public static class Inplace9_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_4 //
				extends AbstractRichOp<Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9>> //
				implements Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9> 
			{
				public GenericTypedInplace9_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_4<I1, I2, I3, IO, I5, I6, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_4();
		}
	}

	public static class Inplace9_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_5 //
				extends AbstractRichOp<Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9>> //
				implements Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9> 
			{
				public GenericTypedInplace9_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_5<I1, I2, I3, I4, IO, I6, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_5();
		}
	}

	public static class Inplace9_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_6 //
				extends AbstractRichOp<Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9>> //
				implements Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9> 
			{
				public GenericTypedInplace9_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_6<I1, I2, I3, I4, I5, IO, I7, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_6();
		}
	}

	public static class Inplace9_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_7 //
				extends AbstractRichOp<Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9>> //
				implements Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9> 
			{
				public GenericTypedInplace9_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_7<I1, I2, I3, I4, I5, I6, IO, I8, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_7();
		}
	}

	public static class Inplace9_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9> //
		implements //
		OpWrapper<Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9>> wrap( //
			final OpInstance<Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_8 //
				extends AbstractRichOp<Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9>> //
				implements Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9> 
			{
				public GenericTypedInplace9_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_8<I1, I2, I3, I4, I5, I6, I7, IO, I9> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_8();
		}
	}

	public static class Inplace9_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO> //
		implements //
		OpWrapper<Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO>> wrap( //
			final OpInstance<Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace9_9 //
				extends AbstractRichOp<Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO>> //
				implements Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO> 
			{
				public GenericTypedInplace9_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity9_9<I1, I2, I3, I4, I5, I6, I7, I8, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace9_9();
		}
	}

	public static class Inplace10_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_1 //
				extends AbstractRichOp<Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_1();
		}
	}

	public static class Inplace10_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_2 //
				extends AbstractRichOp<Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_2();
		}
	}

	public static class Inplace10_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_3 //
				extends AbstractRichOp<Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_3();
		}
	}

	public static class Inplace10_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_4 //
				extends AbstractRichOp<Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_4();
		}
	}

	public static class Inplace10_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_5 //
				extends AbstractRichOp<Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_5();
		}
	}

	public static class Inplace10_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_6 //
				extends AbstractRichOp<Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10>> //
				implements Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10> 
			{
				public GenericTypedInplace10_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_6();
		}
	}

	public static class Inplace10_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_7 //
				extends AbstractRichOp<Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10>> //
				implements Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10> 
			{
				public GenericTypedInplace10_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_7();
		}
	}

	public static class Inplace10_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_8 //
				extends AbstractRichOp<Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10>> //
				implements Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10> 
			{
				public GenericTypedInplace10_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_8();
		}
	}

	public static class Inplace10_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10> //
		implements //
		OpWrapper<Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10>> wrap( //
			final OpInstance<Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_9 //
				extends AbstractRichOp<Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10>> //
				implements Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10> 
			{
				public GenericTypedInplace10_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_9();
		}
	}

	public static class Inplace10_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO> //
		implements //
		OpWrapper<Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO>> wrap( //
			final OpInstance<Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace10_10 //
				extends AbstractRichOp<Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO>> //
				implements Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO> 
			{
				public GenericTypedInplace10_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity10_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace10_10();
		}
	}

	public static class Inplace11_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_1 //
				extends AbstractRichOp<Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_1();
		}
	}

	public static class Inplace11_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_2 //
				extends AbstractRichOp<Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_2();
		}
	}

	public static class Inplace11_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_3 //
				extends AbstractRichOp<Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_3();
		}
	}

	public static class Inplace11_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_4 //
				extends AbstractRichOp<Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_4();
		}
	}

	public static class Inplace11_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_5 //
				extends AbstractRichOp<Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_5();
		}
	}

	public static class Inplace11_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_6 //
				extends AbstractRichOp<Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_6();
		}
	}

	public static class Inplace11_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_7 //
				extends AbstractRichOp<Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11>> //
				implements Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11> 
			{
				public GenericTypedInplace11_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_7();
		}
	}

	public static class Inplace11_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_8 //
				extends AbstractRichOp<Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11>> //
				implements Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11> 
			{
				public GenericTypedInplace11_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_8();
		}
	}

	public static class Inplace11_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_9 //
				extends AbstractRichOp<Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11>> //
				implements Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11> 
			{
				public GenericTypedInplace11_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_9();
		}
	}

	public static class Inplace11_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11> //
		implements //
		OpWrapper<Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11>> wrap( //
			final OpInstance<Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_10 //
				extends AbstractRichOp<Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11>> //
				implements Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11> 
			{
				public GenericTypedInplace11_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_10();
		}
	}

	public static class Inplace11_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO> //
		implements //
		OpWrapper<Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO>> wrap( //
			final OpInstance<Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace11_11 //
				extends AbstractRichOp<Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO>> //
				implements Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO> 
			{
				public GenericTypedInplace11_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity11_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace11_11();
		}
	}

	public static class Inplace12_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_1 //
				extends AbstractRichOp<Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_1();
		}
	}

	public static class Inplace12_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_2 //
				extends AbstractRichOp<Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_2();
		}
	}

	public static class Inplace12_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_3 //
				extends AbstractRichOp<Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_3();
		}
	}

	public static class Inplace12_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_4 //
				extends AbstractRichOp<Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_4();
		}
	}

	public static class Inplace12_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_5 //
				extends AbstractRichOp<Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_5();
		}
	}

	public static class Inplace12_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_6 //
				extends AbstractRichOp<Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_6();
		}
	}

	public static class Inplace12_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_7 //
				extends AbstractRichOp<Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_7();
		}
	}

	public static class Inplace12_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_8 //
				extends AbstractRichOp<Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12>> //
				implements Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12> 
			{
				public GenericTypedInplace12_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_8();
		}
	}

	public static class Inplace12_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_9 //
				extends AbstractRichOp<Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12>> //
				implements Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12> 
			{
				public GenericTypedInplace12_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_9();
		}
	}

	public static class Inplace12_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_10 //
				extends AbstractRichOp<Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12>> //
				implements Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12> 
			{
				public GenericTypedInplace12_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_10();
		}
	}

	public static class Inplace12_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12> //
		implements //
		OpWrapper<Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12>> wrap( //
			final OpInstance<Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_11 //
				extends AbstractRichOp<Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12>> //
				implements Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12> 
			{
				public GenericTypedInplace12_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType, I12 in12Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_11();
		}
	}

	public static class Inplace12_12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO> //
		implements //
		OpWrapper<Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO>> wrap( //
			final OpInstance<Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace12_12 //
				extends AbstractRichOp<Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO>> //
				implements Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO> 
			{
				public GenericTypedInplace12_12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity12_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace12_12();
		}
	}

	public static class Inplace13_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_1 //
				extends AbstractRichOp<Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_1();
		}
	}

	public static class Inplace13_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_2 //
				extends AbstractRichOp<Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_2();
		}
	}

	public static class Inplace13_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_3 //
				extends AbstractRichOp<Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_3();
		}
	}

	public static class Inplace13_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_4 //
				extends AbstractRichOp<Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_4();
		}
	}

	public static class Inplace13_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_5 //
				extends AbstractRichOp<Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_5();
		}
	}

	public static class Inplace13_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_6 //
				extends AbstractRichOp<Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_6();
		}
	}

	public static class Inplace13_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_7 //
				extends AbstractRichOp<Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_7();
		}
	}

	public static class Inplace13_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_8 //
				extends AbstractRichOp<Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_8();
		}
	}

	public static class Inplace13_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_9 //
				extends AbstractRichOp<Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13>> //
				implements Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13> 
			{
				public GenericTypedInplace13_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_9();
		}
	}

	public static class Inplace13_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_10 //
				extends AbstractRichOp<Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13>> //
				implements Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13> 
			{
				public GenericTypedInplace13_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_10();
		}
	}

	public static class Inplace13_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_11 //
				extends AbstractRichOp<Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13>> //
				implements Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13> 
			{
				public GenericTypedInplace13_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType, I12 in12Type, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_11();
		}
	}

	public static class Inplace13_12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13> //
		implements //
		OpWrapper<Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13>> wrap( //
			final OpInstance<Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_12 //
				extends AbstractRichOp<Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13>> //
				implements Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13> 
			{
				public GenericTypedInplace13_12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, IO ioType, I13 in13Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_12();
		}
	}

	public static class Inplace13_13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO> //
		implements //
		OpWrapper<Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO>> wrap( //
			final OpInstance<Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace13_13 //
				extends AbstractRichOp<Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO>> //
				implements Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO> 
			{
				public GenericTypedInplace13_13()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity13_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace13_13();
		}
	}

	public static class Inplace14_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_1 //
				extends AbstractRichOp<Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_1();
		}
	}

	public static class Inplace14_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_2 //
				extends AbstractRichOp<Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_2();
		}
	}

	public static class Inplace14_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_3 //
				extends AbstractRichOp<Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_3();
		}
	}

	public static class Inplace14_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_4 //
				extends AbstractRichOp<Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_4();
		}
	}

	public static class Inplace14_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_5 //
				extends AbstractRichOp<Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_5();
		}
	}

	public static class Inplace14_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_6 //
				extends AbstractRichOp<Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_6();
		}
	}

	public static class Inplace14_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_7 //
				extends AbstractRichOp<Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_7();
		}
	}

	public static class Inplace14_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_8 //
				extends AbstractRichOp<Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_8();
		}
	}

	public static class Inplace14_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_9 //
				extends AbstractRichOp<Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_9();
		}
	}

	public static class Inplace14_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_10 //
				extends AbstractRichOp<Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14>> //
				implements Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14> 
			{
				public GenericTypedInplace14_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_10();
		}
	}

	public static class Inplace14_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_11 //
				extends AbstractRichOp<Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14>> //
				implements Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14> 
			{
				public GenericTypedInplace14_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType, I12 in12Type, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_11();
		}
	}

	public static class Inplace14_12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_12 //
				extends AbstractRichOp<Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14>> //
				implements Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14> 
			{
				public GenericTypedInplace14_12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, IO ioType, I13 in13Type, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_12();
		}
	}

	public static class Inplace14_13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14> //
		implements //
		OpWrapper<Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14>> wrap( //
			final OpInstance<Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_13 //
				extends AbstractRichOp<Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14>> //
				implements Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14> 
			{
				public GenericTypedInplace14_13()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, IO ioType, I14 in14Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_13();
		}
	}

	public static class Inplace14_14OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO> //
		implements //
		OpWrapper<Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO>> wrap( //
			final OpInstance<Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace14_14 //
				extends AbstractRichOp<Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO>> //
				implements Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO> 
			{
				public GenericTypedInplace14_14()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity14_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace14_14();
		}
	}

	public static class Inplace15_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_1 //
				extends AbstractRichOp<Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_1();
		}
	}

	public static class Inplace15_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_2 //
				extends AbstractRichOp<Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_2();
		}
	}

	public static class Inplace15_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_3 //
				extends AbstractRichOp<Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_3();
		}
	}

	public static class Inplace15_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_4 //
				extends AbstractRichOp<Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_4();
		}
	}

	public static class Inplace15_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_5 //
				extends AbstractRichOp<Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_5();
		}
	}

	public static class Inplace15_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_6 //
				extends AbstractRichOp<Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_6();
		}
	}

	public static class Inplace15_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_7 //
				extends AbstractRichOp<Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_7();
		}
	}

	public static class Inplace15_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_8 //
				extends AbstractRichOp<Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_8();
		}
	}

	public static class Inplace15_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_9 //
				extends AbstractRichOp<Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_9();
		}
	}

	public static class Inplace15_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_10 //
				extends AbstractRichOp<Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_10();
		}
	}

	public static class Inplace15_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_11 //
				extends AbstractRichOp<Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15>> //
				implements Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15> 
			{
				public GenericTypedInplace15_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_11();
		}
	}

	public static class Inplace15_12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_12 //
				extends AbstractRichOp<Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15>> //
				implements Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15> 
			{
				public GenericTypedInplace15_12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, IO ioType, I13 in13Type, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_12();
		}
	}

	public static class Inplace15_13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_13 //
				extends AbstractRichOp<Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15>> //
				implements Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15> 
			{
				public GenericTypedInplace15_13()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, IO ioType, I14 in14Type, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_13();
		}
	}

	public static class Inplace15_14OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15> //
		implements //
		OpWrapper<Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15>> wrap( //
			final OpInstance<Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_14 //
				extends AbstractRichOp<Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15>> //
				implements Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15> 
			{
				public GenericTypedInplace15_14()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, IO ioType, I15 in15Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType, in15Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType, in15Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_14();
		}
	}

	public static class Inplace15_15OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO> //
		implements //
		OpWrapper<Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO>> wrap( //
			final OpInstance<Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace15_15 //
				extends AbstractRichOp<Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO>> //
				implements Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO> 
			{
				public GenericTypedInplace15_15()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity15_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace15_15();
		}
	}

	public static class Inplace16_1OpWrapper<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_1 //
				extends AbstractRichOp<Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_1()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(IO ioType, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(ioType, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_1<IO, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_1();
		}
	}

	public static class Inplace16_2OpWrapper<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_2 //
				extends AbstractRichOp<Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_2()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, IO ioType, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, ioType, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_2<I1, IO, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_2();
		}
	}

	public static class Inplace16_3OpWrapper<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_3 //
				extends AbstractRichOp<Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_3()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, IO ioType, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, ioType, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_3<I1, I2, IO, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_3();
		}
	}

	public static class Inplace16_4OpWrapper<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_4 //
				extends AbstractRichOp<Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_4()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, IO ioType, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, ioType, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_4<I1, I2, I3, IO, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_4();
		}
	}

	public static class Inplace16_5OpWrapper<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_5 //
				extends AbstractRichOp<Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_5()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, IO ioType, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, ioType, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_5<I1, I2, I3, I4, IO, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_5();
		}
	}

	public static class Inplace16_6OpWrapper<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_6 //
				extends AbstractRichOp<Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_6()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, IO ioType, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, ioType, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_6<I1, I2, I3, I4, I5, IO, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_6();
		}
	}

	public static class Inplace16_7OpWrapper<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_7 //
				extends AbstractRichOp<Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_7()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, IO ioType, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, ioType, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_7<I1, I2, I3, I4, I5, I6, IO, I8, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_7();
		}
	}

	public static class Inplace16_8OpWrapper<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_8 //
				extends AbstractRichOp<Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_8()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, IO ioType, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, ioType, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_8<I1, I2, I3, I4, I5, I6, I7, IO, I9, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_8();
		}
	}

	public static class Inplace16_9OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_9 //
				extends AbstractRichOp<Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_9()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, IO ioType, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, ioType, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_9<I1, I2, I3, I4, I5, I6, I7, I8, IO, I10, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_9();
		}
	}

	public static class Inplace16_10OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_10 //
				extends AbstractRichOp<Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_10()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, IO ioType, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, ioType, in11Type, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_10<I1, I2, I3, I4, I5, I6, I7, I8, I9, IO, I11, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_10();
		}
	}

	public static class Inplace16_11OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_11 //
				extends AbstractRichOp<Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_11()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, IO ioType, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, ioType, in12Type, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, IO, I12, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_11();
		}
	}

	public static class Inplace16_12OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_12 //
				extends AbstractRichOp<Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16>> //
				implements Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16> 
			{
				public GenericTypedInplace16_12()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, IO ioType, I13 in13Type, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, ioType, in13Type, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, IO, I13, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_12();
		}
	}

	public static class Inplace16_13OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_13 //
				extends AbstractRichOp<Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16>> //
				implements Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16> 
			{
				public GenericTypedInplace16_13()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, IO ioType, I14 in14Type, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, ioType, in14Type, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, IO, I14, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_13();
		}
	}

	public static class Inplace16_14OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_14 //
				extends AbstractRichOp<Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16>> //
				implements Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16> 
			{
				public GenericTypedInplace16_14()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, IO ioType, I15 in15Type, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType, in15Type, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, ioType, in15Type, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, IO, I15, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_14();
		}
	}

	public static class Inplace16_15OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16> //
		implements //
		OpWrapper<Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16>> wrap( //
			final OpInstance<Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_15 //
				extends AbstractRichOp<Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16>> //
				implements Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16> 
			{
				public GenericTypedInplace16_15()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, IO ioType, I16 in16Type) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, ioType, in16Type);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, ioType, in16Type);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, IO, I16> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_15();
		}
	}

	public static class Inplace16_16OpWrapper<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO> //
		implements //
		OpWrapper<Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO>> //
	{

		@Override
		public RichOp<Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO>> wrap( //
			final OpInstance<Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO>> instance, //
			final OpEnvironment env, //
			final MatchingConditions conditions)
		{
			class GenericTypedInplace16_16 //
				extends AbstractRichOp<Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO>> //
				implements Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO> 
			{
				public GenericTypedInplace16_16()
				{
					super(instance, env, conditions);
				}

				@Override
				public void mutate(I1 in1Type, I2 in2Type, I3 in3Type, I4 in4Type, I5 in5Type, I6 in6Type, I7 in7Type, I8 in8Type, I9 in9Type, I10 in10Type, I11 in11Type, I12 in12Type, I13 in13Type, I14 in14Type, I15 in15Type, IO ioType) //
				{
					preprocess(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, ioType);

					// Call the op
					instance.op().mutate(in1Type, in2Type, in3Type, in4Type, in5Type, in6Type, in7Type, in8Type, in9Type, in10Type, in11Type, in12Type, in13Type, in14Type, in15Type, ioType);

					// Log a new execution
					postprocess(ioType);
				}

				@Override
				public Inplaces.Arity16_16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, IO> asOpType() {
					return this;
				}

			}
			return new GenericTypedInplace16_16();
		}
	}



}
