FMOVS	F1, 0x44332211(R2)	// FMOVS	F1, 1144201745(R2)
	FMOVD	F1, 0x1007000(R2)	// FMOVD	F1, 16805888(R2)
	FMOVD	F1, 0x44332211(R2)	// FMOVD	F1, 1144201745(R2)
	FMOVQ	F1, 0x1003000(R2)	// FMOVQ	F1, 16789504(R2)
	FMOVQ	F1, 0x44332211(R2)	// FMOVQ	F1, 1144201745(R2)

	MOVB	0x1000000(R1), R2	// MOVB		16777216(R1), R2
	MOVB	0x44332211(R1), R2	// MOVB		1144201745(R1), R2
	MOVH	0x1000000(R1), R2	// MOVH		16777216(R1), R2

        # TF 2.9
        map sigbuild-r2.9 2.9-python3.9
        map sigbuild-r2.9-python3.8 2.9-python3.8
        map sigbuild-r2.9-python3.9 2.9-python3.9
        map sigbuild-r2.9-python3.10 2.9-python3.10
        # TF 2.10
        map sigbuild-r2.10 2.10-python3.9
        map sigbuild-r2.10-python3.8 2.10-python3.8
        map sigbuild-r2.10-python3.9 2.10-python3.9
        map sigbuild-r2.10-python3.10 2.10-python3.10
        # TF 2.11

// register parses a full register reference where there is no symbol present (as in 4(R0) or R(10) but not sym(SB))
// including forms involving multiple registers such as R1:R2.
func (p *Parser) register(name string, prefix rune) (r1, r2 int16, scale int8, ok bool) {
	// R1 or R(1) R1:R2 R1,R2 R1+R2, or R1*scale.
	r1, ok = p.registerReference(name)
	if !ok {
		return
	}
	if prefix != 0 && prefix != '*' { // *AX is OK.

	MOVV    $0xf731234500000800, R4         // MOVV	$-634687293222811648, R4        // 0400a003a468241684cc3d03

	// ADDV/AND C_DCON12_20S, [r1], r2
	ADDV    $0x273fffff80000000, R4         // ADDV	$2828260563841187840, R4        // 1e000015decf090384f81000
	ADDV    $0x273fffff80000000, R4, R5     // ADDV	$2828260563841187840, R4, R5    // 1e000015decf090385f81000

	// MOVV C_DCON20S_12U, r
	MOVV    $0xfff8000000000800, R4         // MOVV	$-2251799813683200, R4          // 0400a00304000017

	// ADDV/AND C_DCON12_0, [r1], r2
	ADDV	$0x3210000000000000, R4		// ADDV	$3607383301523767296, R4	// 1e840c0384f81000
	ADDV	$0x3210000000000000, R5, R4	// ADDV	$3607383301523767296, R5, R4	// 1e840c03a4f81000

	}

	createdAt := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
	updatedAt := createdAt.Unix()

	data := SerializerStruct{
		Name:            []byte("jinzhu"),
		Roles:           []string{"r1", "r2"},
		Contracts:       map[string]interface{}{"name": "jinzhu", "age": 10},
		EncryptedString: EncryptedString("pass"),
		CreatedTime:     createdAt.Unix(),
		UpdatedTime:     &updatedAt,
		JobInfo: Job{

# limitations under the License.
# ==============================================================================

name: ARM CD

on:
  push:
    tags:
      - v2.**
    branches:
      - r2.**
  schedule:
    - cron: '0 8 * * *'

permissions:
  contents: read

jobs:
  build:
    if: github.repository == 'tensorflow/tensorflow' # Don't do this in forks
    runs-on: [self-hosted, linux, ARM64]

      # on that branch for a workflow.yml file, and we'd have to cherry-pick
      # this file into those branches.
      release_branch:
        description: 'Release branch name (e.g. r2.9)'
        required: true
        type: string
      git_commit:
        description: 'Git commit to cherry-pick'
        required: true
        type: string

permissions:
  contents: read

jobs:

# limitations under the License.
# ==============================================================================

name: ARM CI

on:
  push:
    branches:
      - master
      - r2.**
permissions:
  contents: read

jobs:
  build:
    # Don't do this in forks, and if labeled, only for 'kokoro:force-run'

		r1, size, _ := buf.ReadRune()
		if err := buf.UnreadRune(); err != nil {
			t.Fatalf("UnreadRune(%U) got error %q", r, err)
		}
		r2, nbytes, err := buf.ReadRune()
		if r1 != r2 || r1 != r || nbytes != size || err != nil {
			t.Fatalf("ReadRune(%U) after UnreadRune got %U,%d not %U,%d (err=%s)", r, r2, nbytes, r, size, err)
		}
	}
}

func TestWriteInvalidRune(t *testing.T) {