"CPOPW",
	"MAX",
	"MAXU",
	"MIN",
	"MINU",
	"SEXTB",
	"SEXTH",
	"ZEXTH",
	"ROL",
	"ROLW",
	"ROR",
	"RORI",
	"RORIW",
	"RORW",
	"ORCB",
	"REV8",
	"BCLR",
	"BCLRI",
	"BEXT",
	"BEXTI",
	"BINV",
	"BINVI",
	"BSET",
	"BSETI",
	"WORD",
	"BEQZ",
	"BGEZ",
	"BGT",
	"BGTU",
	"BGTZ",
	"BLE",
	"BLEU",
	"BLEZ",
	"BLTZ",

	}

	PC := pc
	// Special handling for some ops
	startArg := 0
	sep := " "
	opName := inst.Op.String()
	argList := inst.Args[:]

	switch opName {
	case "bc", "bcl", "bca", "bcla", "bclr", "bclrl", "bcctr", "bcctrl", "bctar", "bctarl":
		sfx := inst.Op.String()[2:]
		bo := int(inst.Args[0].(Imm))
		bi := inst.Args[1].(CondReg)
		atsfx := [4]string{"", "?", "-", "+"}
		decsfx := [2]string{"dnz", "dz"}

	RORW	$31, X13				// 9bd6f661 or 9bdff6019b961600b3e6df00
	ORCB	X5, X6					// 13d37228
	REV8	X7, X8					// 13d4836b

	// 1.5: Single-bit Instructions (Zbs)
	BCLR	X23, X24, X25				// b31c7c49
	BCLR	$63, X24				// 131cfc4b
	BCLRI	$1, X25, X26				// 139d1c48
	BEXT	X26, X28, X29				// b35eae49
	BEXT	$63, X28				// 135efe4b
	BEXTI	$1, X29, X30				// 13df1e48
	BINV	X30, X5, X6				// 3393e269

		}
		return op + " " + strings.Join(args, ", ")
	case BCCTRL:
		if int(inst.Args[0].(Imm))&20 == 20 { // unconditional
			return "BL (CTR)"
		}
		return op + " " + strings.Join(args, ",")
	case BCA, BCL, BCLA, BCLRL, BCTAR, BCTARL:
		return op + " " + strings.Join(args, ",")
	}
}

// plan9Arg formats arg (which is the argIndex's arg in inst) according to Plan 9 rules.
//

	BA:             "ba",
	BL:             "bl",
	BLA:            "bla",
	BC:             "bc",
	BCA:            "bca",
	BCL:            "bcl",
	BCLA:           "bcla",
	BCCTR:          "bcctr",
	BCCTRL:         "bcctrl",
	BCLR:           "bclr",
	BCLRL:          "bclrl",
	CMPW:           "cmpw",
	CMPD:           "cmpd",
	CMP:            "cmp",
	CMPWI:          "cmpwi",
	CMPDI:          "cmpdi",

	{as: ABR, a6: C_LR, type_: 18, size: 4},                                          // blr
	{as: ABR, a6: C_CTR, type_: 18, size: 4},                                         // bctr
	{as: ABC, a1: C_U15CON, a2: C_CRBIT, a6: C_BRA, type_: 16, size: 4},              // bc bo, bi, label
	{as: ABC, a1: C_U15CON, a2: C_CRBIT, a6: C_LR, type_: 18, size: 4},               // bclr bo, bi

The following is a brief description of the BC instruction and its commonly
used operands.

BC op1, op2, op3

	  op1: type of branch
	      16 -> bctr (branch on ctr)
	      12 -> bcr  (branch if cr bit is set)
	      8  -> bcr+bctr (branch on ctr and cr values)
		4  -> bcr != 0 (branch if specified cr bit is not set)

		There are more combinations but these are the most common.

	BCL $20,CR0LT,$1,LR             // 4e800821
	BCL $20,CR0LT,$0,LR             // 4e800021
	BCL $20,CR0LT,LR                // 4e800021
	BCL $20,CR0GT,LR                // 4e810021
	BCL 20,CR0LT,LR                 // BCL $20,CR0LT,LR // 4e800021
	BCL 20,undefined_symbol,LR      // BCL $20,CR0LT,LR // 4e800021
	BCL 20,undefined_symbol+1,LR    // BCL $20,CR0GT,LR // 4e810021

  # shellcheck disable=SC2181
  if [[ $? != 0 ]]; then
    echo -e "--- ${red}FAIL:${clr} ${testname}. See ${RESULTS}/${testname} for full logs"
    code=1
  elif [[ "${VERBOSE}" == true ]]; then
    echo -e "--- ${green}PASS:${clr} ${testname}"
  fi
done

	// Restore R2
	ld	2,24(1)

	// Restore LR and pop stack
	addi	1,1,32
	ld 	0,16(1)
	mtlr	0
	blr

.else

// A stub for older binutils
	.globl	notoc_func
	.type	notoc_func, @function
notoc_func:
	// Return 1 to indicate the test was skipped.
	li	3,1
	blr