JMP	(AX)(AX*4)
	JCS	2(PC)
	JMP	R13

// LTYPEN spec4	{ outcode($1, &$2); }
	NOP
	NOP	AX
	NOP	foo+4(SB)

// LTYPES spec5	{ outcode($1, &$2); }
	SHLL	CX, R12
	SHLL	CX, foo+4(SB)
	// Old syntax, still accepted:
	SHLL	CX, R11:AX // SHLL CX, AX, R11

// LTYPEM spec6	{ outcode($1, &$2); }
	MOVL	AX, R11
	MOVL	$4, R11
//	MOVL	AX, 0(AX):DS // no longer works - did it ever?

	VADDPD (AX), X10, X28       // 6261ad085820
	VADDPD (CX)(AX*1), X29, X0  // 62f19500580401
	VADDPD (CX)(AX*1), X1, X28  // 6261f508582401
	VADDPD (CX)(AX*1), X29, X28 // 62619500582401
	VADDPD (CX)(AX*1), X29, X10 // 62719500581401
	VADDPD (CX)(AX*1), X10, X28 // 6261ad08582401
	VADDPD (CX)(AX*2), X29, X0  // 62f19500580441
	VADDPD (CX)(AX*2), X1, X28  // 6261f508582441
	VADDPD (CX)(AX*2), X29, X28 // 62619500582441

MOVUPS (CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 16(CX), X0 AESENC X0, X1 AESENC X0, X2 ADDQ $0x20, CX enc128: MOVUPS (CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 16(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 32(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 48(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 64(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 80(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 96(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 112(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 128(CX), X0 AESENC...

MOVUPS (CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 16(CX), X0 AESENC X0, X1 AESENC X0, X2 ADDQ $0x20, CX enc128: MOVUPS (CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 16(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 32(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 48(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 64(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 80(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 96(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 112(CX), X0 AESENC X0, X1 AESENC X0, X2 MOVUPS 128(CX), X0 AESENC...

	{"$~15", "$-16"},
	{"(((8)&0xf)*4)(SP)", "32(SP)"},
	{"(((8-14)&0xf)*4)(SP)", "40(SP)"},
	{"(6+8)(AX)", "14(AX)"},
	{"(8*4)(BP)", "32(BP)"},
	{"(AX)", "(AX)"},
	{"(AX)(CX*8)", "(AX)(CX*8)"},
	{"(BP)(CX*4)", "(BP)(CX*4)"},
	{"(BP)(DX*4)", "(BP)(DX*4)"},
	{"(BP)(R8*4)", "(BP)(R8*4)"},
	{"(BX)", "(BX)"},
	{"(DI)", "(DI)"},
	{"(DI)(BX*1)", "(DI)(BX*1)"},
	{"(DX)", "(DX)"},
	{"(R9)", "(R9)"},

	CMPL runtime·writeBarrier(SB), $0
	MOVQ (CX)(R15*1), AX // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET
TEXT ·a19(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0
	MOVQ AX, (R15) // ERROR "when dynamic linking, R15 is clobbered by a global variable access and is used here"
	RET
TEXT ·a20(SB), 0, $0-0
	CMPL runtime·writeBarrier(SB), $0

<code>g</code> pointer into.
</p>

<p>
For example, the sequence to load <code>g</code> and <code>m</code>
using <code>CX</code> looks like this:
</p>

<pre>
#include "go_tls.h"
#include "go_asm.h"
...
get_tls(CX)
MOVL	g(CX), AX     // Move g into AX.
MOVL	g_m(AX), BX   // Move g.m into BX.
</pre>

<p>

	SHLL	$4, foo+4(SB)
	SHLL	$4, foo+4(SB):AX // SHLL $4, AX, foo+4(SB)

// LTYPEM spec6	{ outcode(int($1), &$2); }
	MOVL	AX, BX
	MOVL	$4, BX

// LTYPEI spec7	{ outcode(int($1), &$2); }
	IMULL	AX
	IMULL	$4, CX
	IMULL	AX, BX

// LTYPEXC spec9	{ outcode(int($1), &$2); }
	CMPPD	X0, X1, 4
	CMPPD	foo+4(SB), X1, 4

// LTYPEX spec10	{ outcode(int($1), &$2); }
	PINSRD	$1, (AX), X0
	PINSRD	$2, foo+4(FP), X0

Replace existing GSS/CSE code:

```javascript
<!-- Old GSS/CSE Code -->
<script>
  (function() {
    var cx = 'YOUR-CSE-ID';
    var gcse = document.createElement('script');
    gcse.type = 'text/javascript';
    gcse.async = true;
    gcse.src = 'https://cse.google.com/cse.js?cx=' + cx;
    var s = document.getElementsByTagName('script')[0];
    s.parentNode.insertBefore(gcse, s);
  })();
</script>

    SVG_TEST="${OUTPUT_DIR}/test.svg"
    cat > "${SVG_TEST}" << 'EOF'
<svg width="200" height="200" xmlns="http://www.w3.org/2000/svg">
  <rect width="200" height="200" fill="blue"/>
  <circle cx="100" cy="100" r="80" fill="red"/>
</svg>
EOF

    # Test: SVG thumbnail generation
    run_file_test "SVG thumbnail" "${OUTPUT_DIR}/svg_thumb.png" \