std::unique_ptr<TFConcreteFunction>* out) {
  std::unique_ptr<FlatTensorFunction> func;
  TF_RETURN_IF_ERROR(FlatTensorFunction::Create(
      function_def, std::move(captures), ctx, &func));

  out->reset(new TFConcreteFunction(std::move(func), std::move(metadata)));
  return Status();
}

const FunctionMetadata& TFConcreteFunction::GetFunctionMetadata() const {
  return metadata_;
}

Status TFConcreteFunction::MakeCallOp(

    std::unique_ptr<TFSignatureDefFunction>* out) {
  std::unique_ptr<FlatTensorFunction> func;
  TF_RETURN_IF_ERROR(FlatTensorFunction::Create(
      function_def, std::move(captures), ctx, &func));

  out->reset(new TFSignatureDefFunction(std::move(func), std::move(metadata)));
  return Status();
}

const SignatureDefFunctionMetadata&
TFSignatureDefFunction::GetFunctionMetadata() const {
  return metadata_;
}

  PluggableProfilerFactory factory(std::move(profiler), params.destroy_profiler,
                                   std::move(profiler_fns),
                                   params.destroy_profiler_fns);
  std::function<std::unique_ptr<ProfilerInterface>(const ProfileOptions&)>
      create_func = [factory = std::move(factory)](
                        const ProfileOptions& options) mutable {

	// X11 = b_len
	// X12 = b_cap (unused)
	// X13 = byte to find
	AND	$0xff, X13
	MOV	X10, X12		// store base for later
	ADD	X10, X11		// end
	SUB	$1, X10

loop:
	ADD	$1, X10
	BEQ	X10, X11, notfound
	MOVBU	(X10), X14
	BNE	X13, X14, loop

	SUB	X12, X10		// remove base
	RET

notfound:
	MOV	$-1, X10
	RET

TEXT ·IndexByteString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = b_base
	// X11 = b_len

// license that can be found in the LICENSE file.

//go:build !purego

#include "textflag.h"

// func block(dig *digest, p []byte)
TEXT ·block(SB), NOSPLIT|NOFRAME, $0-32
	MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $2, R0                       // SHA-256 function code
	CMPBEQ R4, $0, generic

loop:
	KIMD R0, R2      // compute intermediate message digest (KIMD)

// license that can be found in the LICENSE file.

//go:build !purego

#include "textflag.h"

// func block(dig *digest, p []byte)
TEXT ·block(SB), NOSPLIT|NOFRAME, $0-32
	MOVBZ  ·useAsm(SB), R4
	LMG    dig+0(FP), R1, R3            // R2 = &p[0], R3 = len(p)
	MOVBZ  $3, R0                       // SHA-512 function code
	CMPBEQ R4, $0, generic

loop:
	KIMD R0, R2      // compute intermediate message digest (KIMD)

	JE	_4
	CMPL	BX, $8
	JBE	_5through8
	CMPL	BX, $16
	JBE	_9through16
	MOVL	BX, CX
	SHRL	$2, CX
	REP
	STOSL
	ANDL	$3, BX
	JNE	tail
	RET

_1or2:
	MOVB	AX, (DI)
	MOVB	AX, -1(DI)(BX*1)
	RET
_0:
	RET
_3:
	MOVW	AX, (DI)
	MOVB	AX, 2(DI)
	RET
_4:
	// We need a separate case for 4 to make sure we clear pointers atomically.
	MOVL	AX, (DI)
	RET
_5through8:
	MOVL	AX, (DI)
	MOVL	AX, -4(DI)(BX*1)

	MOVWU.P	R14, 4(R0)
less_than4:
	TBZ	$1, R3, less_than2
	MOVHU.P	2(R1), R15
	MOVHU.P	2(R2), R16
	EORW	R15, R16, R16
	MOVHU.P	R16, 2(R0)
less_than2:
	TBZ	$0, R3, end
	MOVBU	(R1), R17
	MOVBU	(R2), R19
	EORW	R17, R19, R19
	MOVBU	R19, (R0)
end:

    }
}
// end::mkdir-example[]

// tag::move-example[]
tasks.register('moveReports') {
    // Store the build directory into a variable to avoid project reference in the configuration cache
    def dir = buildDir

    doLast {
        ant.move file: "${dir}/reports",
                 todir: "${dir}/toArchive"
    }
}
// end::move-example[]

// tag::delete-example[]
tasks.register('myClean', Delete) {

loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10
	BNE	X12, X15, loop
	ADD	$1, X14
	JMP	loop

done:
	MOV	X14, X10
	RET

TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = s_base
	// X11 = s_len
	// X12 = byte to count
	AND	$0xff, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10