compile_options.use_tuple_arg = false;
    compile_options.always_return_tuple = true;
  }

  return compile_options;
}

// Gets `variables` from `ctx`, locks them and builds XlaCompiler::Arguments
// using them. Stores the arguments in `args`. `variables` and `args` passed in
// will be cleared before populating them.
Status GetAndLockVariablesAndBuildXlaCompilerArguments(

  std::vector<XlaCompiler::Argument> args;
  args.reserve(input_arg_size);

  for (auto& arg_info : flat_arg_shape_and_dtype) {
    XlaCompiler::Argument arg;
    arg.kind = XlaCompiler::Argument::kParameter;
    arg.type = arg_info.dtype;
    arg.shape = arg_info.shape;
    args.push_back(arg);
  }

  // Build Xla Compiler Arguments from concrete_fn.captured_inputs

    def "can configure searchUpwards via build arguments"() {
        given:
        file('build.gradle') << "assert !gradle.startParameter.searchUpwards"

        when:
        withConnection {
            it.newBuild().withArguments('-u').run()
        }

        then:
        noExceptionThrown()
    }

    def "can overwrite task names via build arguments"() {
        given:

            // Typed nulls
            [fromString(), "Runtime.getRuntime().exec(command, null, null as File)", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "Runtime.getRuntime().exec(command as String, null, null)", "", ""],
            [fromObjectList(), "Runtime.getRuntime().exec(command as String[], null, null)", "", ""],

        failure.assertHasCause("Could not create task of type 'CustomTask'.")
        failure.assertHasCause("Unable to determine constructor argument #2: missing parameter of type int, or no service of type int")
    }

    def "fails to create custom task if all constructor arguments missing"() {
        given:
        buildFile << CUSTOM_TASK_WITH_CONSTRUCTOR_ARGS
        buildFile << "tasks.register('myTask', CustomTask)"

                            absl::Span<VariableInfo const> variable_args,
                            Device* device);

  // Add all inputs within `ctx` as XLA arguments (returned by arguments()).
  // `variables` is a map from TensorFlow argument number to resource variable.
  //
  // Assumes that the first `missing_ctx_input_prefix` inputs to the kernel are
  // missing and adjusts input indices accordingly.  All elements in kernel's

      work_list.push_back(use.getOwner());
    }
  }

  for (auto* op : erase_list) {
    op->dropAllUses();
    op->erase();
  }
}

// Updates terminator op arguments of 'func' after removing arguments
// specified in 'arguments_to_erase'.
template <typename T>
void UpdateTerminatorArguments(T& func,
                               const ArrayRef<unsigned> arguments_to_erase,

	MOVD 0(R7), R3

	CMP  R8, $0
	BEQ  docall
	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument

repeat:
	ADD  $8, R7
	MOVD 0(R7), R0      // advance arg pointer by 8 byte
	ADD  $8, R6         // advance LE argument address by 8 byte
	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
	SUB  $1, R8
	CMP  R8, $0
	BNE  repeat

docall:

from unicorn import UnicornMiddleware

app = FastAPI()

app.add_middleware(UnicornMiddleware, some_config="rainbow")
```

`app.add_middleware()` empfängt eine Middleware-Klasse als erstes Argument und dann alle weiteren Argumente, die an die Middleware übergeben werden sollen.

## Integrierte Middleware

**FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie man sie verwendet.

            [fromObjectList(), "execute(command)", "", ""],
            // Spread calls
            [fromString(), "execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "execute(command as String)", "", ""],
        ]
    }