MOVV	8(R4), R16
	MOVV	8(R6), R17
	ADDV	$16, R4
	ADDV	$16, R6
	SUBVU	$1, R14
	BEQ	R16, R17, chunk16_loop
	SUBV	$8, R4
	SUBV	$8, R6

byte_loop:
	BEQ	R4, R12, samebytes
	MOVBU	(R4), R8
	ADDVU	$1, R4
	MOVBU	(R6), R9
	ADDVU	$1, R6
	BEQ	R8, R9, byte_loop

byte_cmp:
	SGTU	R8, R9, R4 // R12 = 1 if (R8 > R9)
	BNE	R0, R4, ret
	MOVV	$-1, R4
	JMP	ret

samebytes:
	SGTU	R5, R7, R8

    def "storing an artifact uses the writable store"() {
        when:
        twoStageStore.move(key, file)

        then:
        1 * writeStore.move(key, file)
        0 * readStore.move(_, _)

        when:
        twoStageStore.add(key, action)

        then:
        1 * writeStore.add(key, action)
        0 * readStore.add(key, action)
    }

// func Count(b []byte, c byte) int
TEXT ·Count(SB), NOSPLIT|NOFRAME, $0-40
	LMG   b+0(FP), R_PTR, R_LEN
	MOVBZ c+24(FP), R_CHAR
	MOVD  $ret+32(FP), R_RET
	BR    countbytebody<>(SB)

// func CountString(s string, c byte) int
TEXT ·CountString(SB), NOSPLIT|NOFRAME, $0-32
	LMG   s+0(FP), R_PTR, R_LEN
	MOVBZ c+16(FP), R_CHAR
	MOVD  $ret+24(FP), R_RET
	BR    countbytebody<>(SB)

// input:

			// The current succeeded interval is behind, so we can move to the next.
			succeededPointer++
		} else if succeededIndexes[succeededPointer].Last > ruleIndexes[rulePointer].Last {
			// The current rule interval is behind, so we can move to the next.
			rulePointer++
		} else {
			// Both intervals end at the same position, we can move to the next succeeded, and next rule.
			succeededPointer++
			rulePointer++
		}

#include "tensorflow/core/platform/errors.h"
#include "tensorflow/core/platform/path.h"

namespace tensorflow {

Asset::Asset(ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)) {}

Status Asset::Create(ImmediateExecutionContext* ctx,
                     const std::string& saved_model_dir,
                     const std::string& asset_filename,

// for more details.
// No argsize here, gc generates argsize info at call site.
TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$20
	NO_LOCAL_POINTERS
	MOVL	DX, 0(SP)
	LEAL	argframe+0(FP), CX
	MOVL	CX, 4(SP)
	MOVB	$0, 16(SP)
	LEAL	16(SP), AX
	MOVL	AX, 8(SP)
	MOVL	$0, 12(SP)
	CALL	·callReflect(SB)
	RET

// methodValueCall is the code half of the function returned by makeMethodValue.

func (l *List) remove(e *Element) {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next = nil // avoid memory leaks
	e.prev = nil // avoid memory leaks
	e.list = nil
	l.len--
}

// move moves e to next to at.
func (l *List) move(e, at *Element) {
	if e == at {
		return
	}
	e.prev.next = e.next
	e.next.prev = e.prev

	e.prev = at
	e.next = at.next
	e.prev.next = e
	e.next.prev = e
}

        this.baseDir = baseDir;
        this.checksumService = checksumService;
    }

    @Override
    public LocallyAvailableResource move(K key, File source) {
        return markAccessed(delegate.move(toPath(key, getChecksum(source)), source));
    }

    @Override
    public Set<? extends LocallyAvailableResource> search(K key) {
        return delegate.search(toPath(key, "*"));
    }

#include "go_asm.h"
#include "go_tls.h"
#include "funcdata.h"
#include "textflag.h"
#include "tls_arm64.h"

TEXT runtime·load_g(SB),NOSPLIT,$0
#ifndef GOOS_darwin
#ifndef GOOS_openbsd
#ifndef GOOS_windows
	MOVB	runtime·iscgo(SB), R0
	CBZ	R0, nocgo
#endif
#endif
#endif

	MRS_TPIDR_R0
#ifdef TLS_darwin
	// Darwin sometimes returns unaligned pointers
	AND	$0xfffffffffffffff8, R0
#endif

// for more details.
// No arg size here, runtime pulls arg map out of the func value.
TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$40
	NO_LOCAL_POINTERS
	MOVD	R12, 8(R15)
	MOVD	$argframe+0(FP), R3
	MOVD	R3, 16(R15)
	MOVB	$0, 40(R15)
	ADD	$40, R15, R3
	MOVD	R3, 24(R15)
	MOVD	$0, 32(R15)
	BL	·callReflect(SB)
	RET

// methodValueCall is the code half of the function returned by makeMethodValue.