/*-
 * #%L
 * Image processing operations for SciJava Ops.
 * %%
 * Copyright (C) 2014 - 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.image.adapt.complexLift;

import net.imglib2.RandomAccessibleInterval;
import org.scijava.function.Computers;
import org.scijava.function.Functions;
import org.scijava.ops.spi.Op;
import org.scijava.ops.spi.OpDependency;

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

public final class FunctionsToComputersAndLift {

	private FunctionsToComputersAndLift() {
		// prevent instantiation of static utility class
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI11FunctionToComputerAndLiftAfter<I1, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Function<I1, O>, Computers.Arity1<RAII1, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Function<I1, O>, Computers.Arity1<I1, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity1<I1, O>, Computers.Arity1<RAII1, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity1<RAII1, RAIO> apply(Function<I1, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI11FunctionToComputerAndLiftBefore<I1, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Function<I1, O>, Computers.Arity1<RAII1, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Function<I1, O>, Function<RAII1, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Function<RAII1, RAIO>, Computers.Arity1<RAII1, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity1<RAII1, RAIO> apply(Function<I1, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI21FunctionToComputerAndLiftAfter<I1, I2, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<BiFunction<I1, I2, O>, Computers.Arity2<RAII1, I2, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<I1, I2, O>, Computers.Arity2<I1, I2, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity2<I1, I2, O>, Computers.Arity2<RAII1, I2, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity2<RAII1, I2, RAIO> apply(BiFunction<I1, I2, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI21FunctionToComputerAndLiftBefore<I1, I2, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<BiFunction<I1, I2, O>, Computers.Arity2<RAII1, I2, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<I1, I2, O>, BiFunction<RAII1, I2, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<RAII1, I2, RAIO>, Computers.Arity2<RAII1, I2, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity2<RAII1, I2, RAIO> apply(BiFunction<I1, I2, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI22FunctionToComputerAndLiftAfter<I1, I2, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<BiFunction<I1, I2, O>, Computers.Arity2<RAII1, RAII2, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<I1, I2, O>, Computers.Arity2<I1, I2, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity2<I1, I2, O>, Computers.Arity2<RAII1, RAII2, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity2<RAII1, RAII2, RAIO> apply(BiFunction<I1, I2, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI22FunctionToComputerAndLiftBefore<I1, I2, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<BiFunction<I1, I2, O>, Computers.Arity2<RAII1, RAII2, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<I1, I2, O>, BiFunction<RAII1, RAII2, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<BiFunction<RAII1, RAII2, RAIO>, Computers.Arity2<RAII1, RAII2, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity2<RAII1, RAII2, RAIO> apply(BiFunction<I1, I2, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI31FunctionToComputerAndLiftAfter<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, I2, I3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<I1, I2, I3, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, I2, I3, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, I2, I3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI31FunctionToComputerAndLiftBefore<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, I2, I3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Functions.Arity3<RAII1, I2, I3, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<RAII1, I2, I3, RAIO>, Computers.Arity3<RAII1, I2, I3, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, I2, I3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI32FunctionToComputerAndLiftAfter<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, I3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<I1, I2, I3, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, I3, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, RAII2, I3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI32FunctionToComputerAndLiftBefore<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, I3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Functions.Arity3<RAII1, RAII2, I3, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<RAII1, RAII2, I3, RAIO>, Computers.Arity3<RAII1, RAII2, I3, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, RAII2, I3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI33FunctionToComputerAndLiftAfter<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, RAII3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<I1, I2, I3, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, RAII3, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, RAII2, RAII3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI33FunctionToComputerAndLiftBefore<I1, I2, I3, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity3<I1, I2, I3, O>, Computers.Arity3<RAII1, RAII2, RAII3, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<I1, I2, I3, O>, Functions.Arity3<RAII1, RAII2, RAII3, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity3<RAII1, RAII2, RAII3, RAIO>, Computers.Arity3<RAII1, RAII2, RAII3, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity3<RAII1, RAII2, RAII3, RAIO> apply(Functions.Arity3<I1, I2, I3, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI41FunctionToComputerAndLiftAfter<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, I2, I3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<I1, I2, I3, I4, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, I2, I3, I4, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, I2, I3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI41FunctionToComputerAndLiftBefore<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, I2, I3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Functions.Arity4<RAII1, I2, I3, I4, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<RAII1, I2, I3, I4, RAIO>, Computers.Arity4<RAII1, I2, I3, I4, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, I2, I3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI42FunctionToComputerAndLiftAfter<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, I3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<I1, I2, I3, I4, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, I3, I4, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, I3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI42FunctionToComputerAndLiftBefore<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, I3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Functions.Arity4<RAII1, RAII2, I3, I4, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<RAII1, RAII2, I3, I4, RAIO>, Computers.Arity4<RAII1, RAII2, I3, I4, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, I3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI43FunctionToComputerAndLiftAfter<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<I1, I2, I3, I4, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI43FunctionToComputerAndLiftBefore<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Functions.Arity4<RAII1, RAII2, RAII3, I4, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<RAII1, RAII2, RAII3, I4, RAIO>, Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, RAII3, I4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI44FunctionToComputerAndLiftAfter<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<I1, I2, I3, I4, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI44FunctionToComputerAndLiftBefore<I1, I2, I3, I4, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity4<I1, I2, I3, I4, O>, Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<I1, I2, I3, I4, O>, Functions.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>, Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity4<RAII1, RAII2, RAII3, RAII4, RAIO> apply(Functions.Arity4<I1, I2, I3, I4, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI51FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<I1, I2, I3, I4, I5, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI51FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Functions.Arity5<RAII1, I2, I3, I4, I5, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<RAII1, I2, I3, I4, I5, RAIO>, Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, I2, I3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI52FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<I1, I2, I3, I4, I5, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI52FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Functions.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>, Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, I3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI53FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<I1, I2, I3, I4, I5, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI53FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Functions.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>, Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, I4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI54FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<I1, I2, I3, I4, I5, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI54FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Functions.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, RAII4, I5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI55FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<I1, I2, I3, I4, I5, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI55FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<I1, I2, I3, I4, I5, O>, Functions.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>, Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity5<RAII1, RAII2, RAII3, RAII4, RAII5, RAIO> apply(Functions.Arity5<I1, I2, I3, I4, I5, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI61FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI61FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>, Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, I2, I3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI62FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI62FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>, Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, I3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI63FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI63FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>, Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, I4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI64FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI64FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, I5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI65FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI65FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, I6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI66FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<I1, I2, I3, I4, I5, I6, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI66FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<I1, I2, I3, I4, I5, I6, O>, Functions.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>, Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity6<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAIO> apply(Functions.Arity6<I1, I2, I3, I4, I5, I6, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI71FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI71FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>, Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, I2, I3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI72FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI72FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>, Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, I3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI73FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI73FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>, Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, I4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI74FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI74FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI75FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI75FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI76FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI76FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI77FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI77FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O>, Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>, Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity7<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAIO> apply(Functions.Arity7<I1, I2, I3, I4, I5, I6, I7, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI81FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI81FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>, Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, I2, I3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI82FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI82FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, I3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI83FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI83FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI84FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI84FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI85FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI85FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI86FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI86FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI87FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI87FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI88FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI88FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O>, Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>, Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity8<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAIO> apply(Functions.Arity8<I1, I2, I3, I4, I5, I6, I7, I8, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI91FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI91FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI92FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI92FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI93FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI93FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI94FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI94FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI95FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI95FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI96FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI96FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI97FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI97FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI98FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI98FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI99FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI99FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O>, Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>, Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity9<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAIO> apply(Functions.Arity9<I1, I2, I3, I4, I5, I6, I7, I8, I9, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI101FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI101FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI102FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI102FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI103FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI103FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI104FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI104FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI105FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI105FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI106FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI106FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI107FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI107FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI108FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI108FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI109FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI109FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1010FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1010FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O>, Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>, Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity10<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAIO> apply(Functions.Arity10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI111FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI111FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI112FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI112FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI113FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI113FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI114FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI114FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI115FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI115FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI116FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI116FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI117FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI117FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI118FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI118FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI119FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI119FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1110FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1110FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1111FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1111FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O>, Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>, Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity11<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAIO> apply(Functions.Arity11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI121FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI121FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI122FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI122FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI123FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI123FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI124FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI124FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI125FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI125FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI126FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI126FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI127FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI127FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI128FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI128FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI129FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI129FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1210FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1210FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1211FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1211FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1212FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1212FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O>, Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>, Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity12<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAIO> apply(Functions.Arity12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI131FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI131FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI132FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI132FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI133FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI133FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI134FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI134FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI135FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI135FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI136FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI136FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI137FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI137FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI138FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI138FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI139FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI139FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1310FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1310FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1311FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1311FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1312FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1312FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1313FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1313FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O>, Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>, Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity13<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAIO> apply(Functions.Arity13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI141FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI141FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI142FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI142FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI143FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI143FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI144FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI144FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI145FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI145FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI146FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI146FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI147FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI147FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI148FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI148FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI149FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI149FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1410FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1410FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1411FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1411FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1412FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1412FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1413FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1413FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1414FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1414FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O>, Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>, Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity14<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAIO> apply(Functions.Arity14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI151FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI151FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI152FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI152FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI153FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI153FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI154FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI154FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI155FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI155FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI156FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI156FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI157FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI157FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI158FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI158FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI159FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI159FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1510FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1510FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1511FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1511FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1512FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1512FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1513FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1513FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1514FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1514FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1515FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1515FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O>, Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>, Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity15<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAIO> apply(Functions.Arity15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI161FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            The second parameter type
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI161FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI162FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            The third parameter type
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI162FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI163FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            The fourth parameter type
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI163FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI164FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            The fifth parameter type
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI164FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI165FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            The sixth parameter type
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI165FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI166FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            The seventh parameter type
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI166FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI167FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            The eighth parameter type
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI167FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, I8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI168FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            The ninth parameter type
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI168FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, I9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI169FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            The tenth parameter type
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI169FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, I10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1610FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            The eleventh parameter type
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1610FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, I11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1611FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            The twelfth parameter type
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1611FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, I12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1612FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            The thirteenth parameter type
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1612FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, I13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1613FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            The fourteenth parameter type
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1613FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, I14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1614FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            The fifteenth parameter type
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1614FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, I15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1615FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <I16>
	 *            The sixteenth parameter type
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1615FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, I16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Adapts first, then lifts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <I16>
	 *            Type of the sixteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-100.'
	 */
	 public static class RAI1616FunctionToComputerAndLiftAfter<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAII16 extends RandomAccessibleInterval<I16>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>> adapter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Computers.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>> lifter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return lifter.apply(adapter.apply(function));
		}
	}

	/**
	 * Lifting function for mapping Functions Ops to Computers that operate on RandomAccessibleIntervals.
	 * Lifts first, then adapts.
	 *
	 * @param <I1>
	 *            Type of the first RAI
	 * @param <I2>
	 *            Type of the second RAI
	 * @param <I3>
	 *            Type of the third RAI
	 * @param <I4>
	 *            Type of the fourth RAI
	 * @param <I5>
	 *            Type of the fifth RAI
	 * @param <I6>
	 *            Type of the sixth RAI
	 * @param <I7>
	 *            Type of the seventh RAI
	 * @param <I8>
	 *            Type of the eighth RAI
	 * @param <I9>
	 *            Type of the ninth RAI
	 * @param <I10>
	 *            Type of the tenth RAI
	 * @param <I11>
	 *            Type of the eleventh RAI
	 * @param <I12>
	 *            Type of the twelfth RAI
	 * @param <I13>
	 *            Type of the thirteenth RAI
	 * @param <I14>
	 *            Type of the fourteenth RAI
	 * @param <I15>
	 *            Type of the fifteenth RAI
	 * @param <I16>
	 *            Type of the sixteenth RAI
	 * @param <O>
	 *            The RAI return type
	 *@implNote op names='engine.adapt', priority='-99.'
	 */
	 public static class RAI1616FunctionToComputerAndLiftBefore<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O, RAII1 extends RandomAccessibleInterval<I1>, RAII2 extends RandomAccessibleInterval<I2>, RAII3 extends RandomAccessibleInterval<I3>, RAII4 extends RandomAccessibleInterval<I4>, RAII5 extends RandomAccessibleInterval<I5>, RAII6 extends RandomAccessibleInterval<I6>, RAII7 extends RandomAccessibleInterval<I7>, RAII8 extends RandomAccessibleInterval<I8>, RAII9 extends RandomAccessibleInterval<I9>, RAII10 extends RandomAccessibleInterval<I10>, RAII11 extends RandomAccessibleInterval<I11>, RAII12 extends RandomAccessibleInterval<I12>, RAII13 extends RandomAccessibleInterval<I13>, RAII14 extends RandomAccessibleInterval<I14>, RAII15 extends RandomAccessibleInterval<I15>, RAII16 extends RandomAccessibleInterval<I16>, RAIO extends RandomAccessibleInterval<O>>
		 implements Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>>,
			Op
	{
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O>, Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>> lifter;
		@OpDependency(name = "engine.adapt", hints={"adaptation.FORBIDDEN"})
		Function<Functions.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>, Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO>> adapter;

		/**
		 * @param function - the Function to convert
		 * @return {@code function} as a computer
		 */
		@Override
		public Computers.Arity16<RAII1, RAII2, RAII3, RAII4, RAII5, RAII6, RAII7, RAII8, RAII9, RAII10, RAII11, RAII12, RAII13, RAII14, RAII15, RAII16, RAIO> apply(Functions.Arity16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, O> function) {
			return adapter.apply(lifter.apply(function));
		}
	}
}
