# NB: a `for` loop captures its iteration list before it begins, so
        # changing the positional parameters here affects neither the number of
        # iterations, nor the values presented in `arg`.
        shift                   # remove old arg
        set -- "$@" "$arg"      # push replacement arg
    done
fi


# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

      return (double) value;
    }
    // The top bit is set, which means that the double value is going to come from the top 53 bits.
    // So we can ignore the bottom 11, except for rounding. We can unsigned-shift right 1, aka
    // unsigned-divide by 2, and convert that. Then we'll get exactly half of the desired double
    // value. But in the specific case where the bottom two bits of the original number are 01, we

        MAVEN_MAIN_CLASS="org.apache.maven.cling.MavenShellCling"
        ;;
      --up)
        MAVEN_MAIN_CLASS="org.apache.maven.cling.MavenUpCling"
        ;;
      *)
        ;;
    esac
    shift
  done
}

handle_args "$@"
MAVEN_MAIN_CLASS=${MAVEN_MAIN_CLASS:=org.apache.maven.cling.MavenCling}

# Build command string for eval
cmd="\"$JAVACMD\" \
  $MAVEN_OPTS \
  $MAVEN_DEBUG_OPTS \

//	LMOVW mreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVW	M1, R1 // 40010800
	MOVV	M1, R1 // 40210800


//
// integer operations
// logical instructions
// shift instructions
// unary instructions
//
//	LADDW rreg ',' sreg ',' rreg
//	{
//		outcode(int($1), &$2, int($4), &$6);
//	}
	ADD	R5, R9, R10	// 01255020
	ADDU	R13, R14, R19	// 01cd9821

			comment: "in the 世界",
			flags:   0x808,
		},
		{
			name:    "the replacement rune is �",
			comment: "the replacement rune is �",
			flags:   0x808,
		},
		{
			// Name is Japanese encoded in Shift JIS.
			name:    "\x93\xfa\x96{\x8c\xea.txt",
			comment: "in the 世界",
			flags:   0x008, // UTF-8 must not be set
		},
	}

	// write a zip file
	buf := new(bytes.Buffer)
	w := NewWriter(buf)

		} else {
			p.errorf("bad addr size for DATA argument: %d", sz)
		}
	}
}

// asmGlobl assembles a GLOBL pseudo-op.
// GLOBL shifts<>(SB),8,$256
// GLOBL shifts<>(SB),$256
func (p *Parser) asmGlobl(operands [][]lex.Token) {
	if len(operands) != 2 && len(operands) != 3 {
		p.errorf("expect two or three operands for GLOBL")
		return
	}

	VXORVX		X11, V2, V0, V3			// d7c1252c
	VXORVI		$15, V2, V3			// d7b1272e
	VXORVI		$15, V2, V0, V3			// d7b1272c
	VNOTV		V2, V3				// d7b12f2e
	VNOTV		V2, V0, V3			// d7b12f2c

	// 31.11.6: Vector Single-Width Shift Instructions
	VSLLVV		V1, V2, V3			// d7812096
	VSLLVV		V1, V2, V0, V3			// d7812094
	VSLLVX		X11, V2, V3			// d7c12596
	VSLLVX		X11, V2, V0, V3			// d7c12594
	VSLLVI		$15, V2, V3			// d7b12796

		// If we've already hit EOF or an I/O error, we are done.
		if s.err != nil {
			// Shut it down.
			s.start = 0
			s.end = 0
			return false
		}
		// Must read more data.
		// First, shift data to beginning of buffer if there's lots of empty space
		// or space is needed.
		if s.start > 0 && (s.end == len(s.buf) || s.start > len(s.buf)/2) {
			copy(s.buf, s.buf[s.start:s.end])
			s.end -= s.start

	// and accept the same constants.
	MOVW $2147483648, R5            // 64058000
	MOVWZ $-2147483648, R5          // 3ca08000

	// TODO: These are preprocessed by the assembler into MOVD $const>>shift, R5; SLD $shift, R5.
	//       This only captures the MOVD. Should the SLD be appended to the encoding by the test?
	// Hex constant 0x20004000000
	MOVD $2199090364416, R5         // 60058001
	// Hex constant 0xFFFFFE0004000000

		// local character encoding. Most encoding are compatible with a large
		// subset of CP-437, which itself is ASCII-like.
		//
		// Forbid 0x7e and 0x5c since EUC-KR and Shift-JIS replace those
		// characters with localized currency and overline characters.
		if r < 0x20 || r > 0x7d || r == 0x5c {
			if !utf8.ValidRune(r) || (r == utf8.RuneError && size == 1) {
				return false, false
			}