package p

const (
	// 0-octals
	_	= 0
	_	= 0123
	_	= 0123456

	_	= 0_123
	_	= 0123_456

	// decimals
	_	= 1
	_	= 1234
	_	= 1234567

	_	= 1_234
	_	= 1_234_567

	// hexadecimals
	_	= 0x0
	_	= 0x1234
	_	= 0xcafef00d

	_	= 0X0
	_	= 0X1234
	_	= 0XCAFEf00d

	_	= 0X_0
	_	= 0X_1234
	_	= 0X_CAFE_f00d

	// octals
	_	= 0o0
	_	= 0o1234
	_	= 0o01234567

	_	= 0O0

package p

const (
	// 0-octals
	_ = 0
	_ = 0123
	_ = 0123456

	_ = 0_123
	_ = 0123_456

	// decimals
	_ = 1
	_ = 1234
	_ = 1234567

	_ = 1_234
	_ = 1_234_567

	// hexadecimals
	_ = 0x0
	_ = 0x1234
	_ = 0xcafef00d

	_ = 0X0
	_ = 0X1234
	_ = 0XCAFEf00d

	_ = 0X_0
	_ = 0X_1234
	_ = 0X_CAFE_f00d

	// octals
	_ = 0o0
	_ = 0o1234
	_ = 0o01234567

	_ = 0O0

// of equal values.

package literals

func _() {
	// 0-octals
	assert(0_123 == 0123)
	assert(0123_456 == 0123456)

	// decimals
	assert(1_234 == 1234)
	assert(1_234_567 == 1234567)

	// hexadecimals
	assert(0X_0 == 0)
	assert(0X_1234 == 0x1234)
	assert(0X_CAFE_f00d == 0xcafef00d)

	// octals
	assert(0o0 == 0)
	assert(0o1234 == 01234)
	assert(0o01234567 == 01234567)

	if !cond {
		panic("assertion failed")
	}
}

func equal(x, y interface{}) bool {
	if x != y {
		fmt.Printf("%g != %g\n", x, y)
		return false
	}
	return true
}

func main() {
	// 0-octals
	assert(0_1 == 01)
	assert(012 == 012)
	assert(0_1_2 == 012)
	assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility

// Format implements [fmt.Formatter]. It accepts the formats
// 'b' (binary), 'o' (octal with 0 prefix), 'O' (octal with 0o prefix),
// 'd' (decimal), 'x' (lowercase hexadecimal), and
// 'X' (uppercase hexadecimal).
// Also supported are the full suite of package fmt's format
// flags for integral types, including '+' and ' ' for sign
// control, '#' for leading zero in octal and for hexadecimal,
// a leading "0x" or "0X" for "%#x" and "%#X" respectively,

			return 0
		}
		if inv == 0xff {
			return ^int64(x)
		}
		return int64(x)
	}

	// Normal case is base-8 (octal) format.
	return p.parseOctal(b)
}

// formatNumeric encodes x into b using base-8 (octal) encoding if possible.
// Otherwise it will attempt to use base-256 (binary) encoding.
func (f *formatter) formatNumeric(b []byte, x int64) {
	if fitsInOctal(len(b), x) {

        assertInvalidUnixPermission("812", "'812' isn't a proper Unix permission. Can't be parsed as octal number.");
        assertInvalidUnixPermission("790", "'790' isn't a proper Unix permission. Can't be parsed as octal number.");
        assertInvalidUnixPermission("649", "'649' isn't a proper Unix permission. Can't be parsed as octal number.");

package p

const (
	_ = 1_       // ERROR "'_' must separate successive digits"
	_ = 0b       // ERROR "binary literal has no digits|invalid numeric literal"
	_ = 0o       // ERROR "octal literal has no digits|invalid numeric literal"
	_ = 0x       // ERROR "hexadecimal literal has no digits|invalid numeric literal"
	_ = 0xde__ad // ERROR "'_' must separate successive digits"

  empty-values: disable
  hyphens: enable
  indentation: disable
  key-duplicates: enable
  key-ordering: disable
  line-length: disable
  new-line-at-end-of-file: disable
  new-lines: enable
  octal-values: disable
  quoted-strings: disable
  trailing-spaces: disable

            withExclusiveAccessToCache(baseDir) { cacheDir ->
                // TODO GlobalCache require(!cacheDir.isDirectory)
                Files.createDirectories(cacheDir.toPath())
                chmod(cacheDir, 448) // octal 0700
                markAccessed(cacheDir)
                val stateFiles = mutableListOf<File>()
                val layout = WriteableLayout(cacheDir, stateFiles::add)
                try {