// Code generated by mkpreempt.go; DO NOT EDIT.

#include "go_asm.h"
#include "textflag.h"

TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0
	MOV X1, -464(X2)
	SUB $464, X2
	MOV X5, 8(X2)
	MOV X6, 16(X2)
	MOV X7, 24(X2)
	MOV X8, 32(X2)
	MOV X9, 40(X2)
	MOV X10, 48(X2)
	MOV X11, 56(X2)
	MOV X12, 64(X2)
	MOV X13, 72(X2)
	MOV X14, 80(X2)
	MOV X15, 88(X2)
	MOV X16, 96(X2)
	MOV X17, 104(X2)
	MOV X18, 112(X2)

	MOVD F24, 424(R29)
	MOVD F25, 432(R29)
	MOVD F26, 440(R29)
	MOVD F27, 448(R29)
	MOVD F28, 456(R29)
	MOVD F29, 464(R29)
	MOVD F30, 472(R29)
	MOVD F31, 480(R29)
	#endif
	CALL ·asyncPreempt2(SB)
	#ifndef GOMIPS64_softfloat
	MOVD 480(R29), F31
	MOVD 472(R29), F30
	MOVD 464(R29), F29
	MOVD 456(R29), F28
	MOVD 448(R29), F27
	MOVD 440(R29), F26
	MOVD 432(R29), F25
	MOVD 424(R29), F24
	MOVD 416(R29), F23

	FMOVD F24, 448(R1)
	FMOVD F25, 456(R1)
	FMOVD F26, 464(R1)
	FMOVD F27, 472(R1)
	FMOVD F28, 480(R1)
	FMOVD F29, 488(R1)
	FMOVD F30, 496(R1)
	FMOVD F31, 504(R1)
	MOVFL FPSCR, F0
	FMOVD F0, 512(R1)
	CALL ·asyncPreempt2(SB)
	FMOVD 512(R1), F0
	MOVFL F0, FPSCR
	FMOVD 504(R1), F31
	FMOVD 496(R1), F30
	FMOVD 488(R1), F29
	FMOVD 480(R1), F28
	FMOVD 472(R1), F27
	FMOVD 464(R1), F26
	FMOVD 456(R1), F25
	FMOVD 448(R1), F24

	MOVD F24, 408(R3)
	MOVD F25, 416(R3)
	MOVD F26, 424(R3)
	MOVD F27, 432(R3)
	MOVD F28, 440(R3)
	MOVD F29, 448(R3)
	MOVD F30, 456(R3)
	MOVD F31, 464(R3)
	MOVV FCC0, R4
	MOVV R4, 472(R3)
	CALL ·asyncPreempt2(SB)
	MOVV 472(R3), R4
	MOVV R4, FCC0
	MOVD 464(R3), F31
	MOVD 456(R3), F30
	MOVD 448(R3), F29
	MOVD 440(R3), F28
	MOVD 432(R3), F27
	MOVD 424(R3), F26
	MOVD 416(R3), F25
	MOVD 408(R3), F24

// division of 64. In the cputicks case it's a bit more complex.
//
// For x86, on a 3 GHz machine, we'd want to divide by 3*64 to hit our target.
// To keep the division operation efficient, we round that up to 4*64, or 256.
// Given what cputicks represents, we use this on all other platforms except
// for PowerPC.
// The suggested increment frequency for PowerPC's time base register is

  TestBitcastOp(&int64_input, DT_UINT8, TensorShape({8}), error::OK);
}

TEST(BitcastOpTest, TestCastToSameSize) {
  Tensor int32_input(DT_UINT32, {4, 6});
  TestBitcastOp(&int32_input, DT_UINT8, TensorShape({4, 6, 4}), error::OK);
}

TEST(BitcastOpTest, TestImpossibleCast) {
  Tensor int8_input(DT_UINT8, {1});
  TestBitcastOp(&int8_input, DT_UINT32, TensorShape(), error::INVALID_ARGUMENT);
}

	SYS_NECP_MATCH_POLICY              = 460
	SYS_GETATTRLISTBULK                = 461
	SYS_CLONEFILEAT                    = 462
	SYS_OPENAT                         = 463
	SYS_OPENAT_NOCANCEL                = 464
	SYS_RENAMEAT                       = 465
	SYS_FACCESSAT                      = 466
	SYS_FCHMODAT                       = 467
	SYS_FCHOWNAT                       = 468
	SYS_FSTATAT                        = 469

	SYS_NECP_MATCH_POLICY              = 460
	SYS_GETATTRLISTBULK                = 461
	SYS_CLONEFILEAT                    = 462
	SYS_OPENAT                         = 463
	SYS_OPENAT_NOCANCEL                = 464
	SYS_RENAMEAT                       = 465
	SYS_FACCESSAT                      = 466
	SYS_FCHMODAT                       = 467
	SYS_FCHOWNAT                       = 468
	SYS_FSTATAT                        = 469

DATA ·erfcrodataL38<> + 440(SB)/8, $0.344449755901841897E-01
DATA ·erfcrodataL38<> + 448(SB)/8, $0.130890907240765465E-01
DATA ·erfcrodataL38<> + 456(SB)/8, $-.459266344100642687E-03
DATA ·erfcrodataL38<> + 464(SB)/8, $-.337888800856913728E-02
DATA ·erfcrodataL38<> + 472(SB)/8, $-.159103061687062373E-02
DATA ·erfcrodataL38<> + 480(SB)/8, $-.501128905515922644E-04
DATA ·erfcrodataL38<> + 488(SB)/8, $0.262775855852903132E-03

		m3 := h2r1

		t0 := m0.lo
		t1, c := bits.Add64(m1.lo, m0.hi, 0)
		t2, c := bits.Add64(m2.lo, m1.hi, c)
		t3, _ := bits.Add64(m3.lo, m2.hi, c)

		// Now we have the result as 4 64-bit limbs, and we need to reduce it
		// modulo 2¹³⁰ - 5. The special shape of this Crandall prime lets us do
		// a cheap partial reduction according to the reduction identity
		//