BEQ	done
copy_4:				// no carry flag, copy the rest
	vwOneIterCopy(R0, done)
	B	copy_4

// func shlVU(z, x []Word, s uint) (c Word)
// This implementation handles the shift operation from the high word to the low word,
// which may be an error for the case where the low word of x overlaps with the high
// word of z. When calling this function directly, you need to pay attention to this
// situation.
TEXT ·shlVU(SB),NOSPLIT,$0

			}
			prev = '_'
		} else {
			// convert rune into digit value d1
			var d1 Word
			switch {
			case '0' <= ch && ch <= '9':
				d1 = Word(ch - '0')
			case 'a' <= ch && ch <= 'z':
				d1 = Word(ch - 'a' + 10)
			case 'A' <= ch && ch <= 'Z':
				if b <= maxBaseSmall {
					d1 = Word(ch - 'A' + 10)
				} else {
					d1 = Word(ch - 'A' + maxBaseSmall)
				}
			default:
				d1 = MaxBase + 1
			}

	FMOVD	F0, F8
	SRAD	$32, R7
	WORD	$0xC0193FE6 //iilf  %r1,1072079005
	BYTE	$0xA0
	BYTE	$0x9D
	WORD	$0xB91700C7 //llgtr %r12,%r7
	MOVW	R12, R8
	MOVW	R1, R6
	CMPBGT	R8, R6, L2
	WORD	$0xC0193BFF //iilf  %r1,1006632959
	BYTE	$0xFF
	BYTE	$0xFF
	MOVW	R1, R6
	CMPBGT	R8, R6, L13
L3:
	FMOVD	216(R9), F0
	FMADD	F0, F8, F8
L1:
	FMOVD	F8, ret+8(FP)
	RET
L2:
	WORD	$0xC0193FEF	//iilf	%r1,1072693247
	BYTE	$0xFF

    .386
    .model    flat

PUBLIC    _sum
_TEXT     SEGMENT
_sum    PROC
    mov    eax, DWORD PTR 4[esp]
    add    eax, DWORD PTR 8[esp]
    ret    0
_sum    ENDP
_TEXT   ENDS

        }

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc) {
            this(word, startOffset, endOffset, posInc, Integer.MAX_VALUE); // Integer.MAX_VALUE for seq means unused
        }

        public MyToken(final String word, final int startOffset, final int endOffset, final int posInc, final int seq) {
            this.word = word;
            this.startOffset = startOffset;

	FMOVDP  F0, ret+16(FP)
	RET
not_finite:
// test bits for -Inf or +Inf
	MOVL    p_hi+4(FP), AX  // high word p
	ORL     p_lo+0(FP), AX  // low word p
	ANDL    $0x7fffffff, AX
	CMPL    AX, $0x7ff00000
	JEQ     is_inf
	MOVL    q_hi+12(FP), AX  // high word q
	ORL     q_lo+8(FP), AX   // low word q
	ANDL    $0x7fffffff, AX
	CMPL    AX, $0x7ff00000
	JEQ     is_inf

	SBBQ CX, CX		// save CF

	ADDQ $1, SI		// i++
	SUBQ $1, DI		// n--
	JG L2			// if n > 0 goto L2

E2:	NEGQ CX
	MOVQ CX, c+72(FP)	// return c
	RET


// func addVW(z, x []Word, y Word) (c Word)
TEXT ·addVW(SB),NOSPLIT,$0
	MOVQ z_len+8(FP), DI
	CMPQ DI, $32
	JG large
	MOVQ x+24(FP), R8
	MOVQ y+48(FP), CX	// c = y
	MOVQ z+0(FP), R10

	MOVQ $0, SI		// i = 0

	FMOVD   tanhrodataL18<>+32(SB), F4
	WORD    $0xB9270022     //lhr %r2,%r2
	WFMADB  V3, V1, V4, V1
	FMOVD   tanhrodataL18<>+24(SB), F4
	WFMADB  V3, V2, V4, V3
	WFMADB  V0, V5, V0, V2
	WFMADB  V0, V1, V3, V0
	WORD    $0xA7183ECF     //lhi %r1,16079
	WFMADB  V0, V2, V5, V2
	FMUL    F6, F2
	MOVW    R2, R10
	MOVW    R1, R11
	CMPBLE  R10, R11, L16
	FMOVD   F6, F0
	WORD    $0xED005010     //adb %f0,.L28-.L18(%r5)

#include <errno.h>
#include "libcgo.h"
#include "libcgo_windows.h"

static void threadentry(void*);
static void (*setg_gcc)(void*);
static DWORD *tls_g;

void
x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase)
{
	setg_gcc = setg;
	tls_g = (DWORD *)tlsg;
}


void
_cgo_sys_thread_start(ThreadStart *ts)
{
	_cgo_beginthread(threadentry, ts);
}

	FMOVD   x+0(FP), F0
	MOVD    $log10rodataL19<>+0(SB), R9
	FMOVD   F0, x-8(SP)
	WORD    $0xC0298006     //iilf %r2,2147909631
	BYTE    $0x7F
	BYTE    $0xFF
	WORD    $0x5840F008     //l %r4, 8(%r15)
	SUBW    R4, R2, R3
	RISBGZ	$32, $47, $0, R3, R5
	MOVH    $0x0, R1
	RISBGN	$0, $31, $32, R5, R1
	WORD    $0xC0590016     //iilf %r5,1507327
	BYTE    $0xFF
	BYTE    $0xFF
	MOVW    R4, R10
	MOVW    R5, R11