sóc
solament
sols
son 
són
sons 
sota
sou
t'ha
t'han
t'he
ta
tal
també
tampoc
tan
tant
tanta
tantes
teu
teus
teva
teves
ton
tons
tot
tota
totes
tots
un
una
unes
uns
us
va
vaig
vam
van
vas
veu
vosaltres
vostra
vostre

		}
	}
	if n != 1 {
		center = -1 // no single hole
	}
}

var moves int // number of times move is called

// move tests if there is a peg at position pos that can jump over another peg
// in direction dir. If the move is valid, it is executed and move returns true.
// Otherwise, move returns false.
func move(pos, dir int) bool {
	moves++
	if board[pos] == '●' && board[pos+dir] == '●' && board[pos+2*dir] == '○' {

}

var Source, Sink T

func newT() T {
	return T{
		a: [2]byte{1, 2},
		b: [2]uint16{1, 2},
		c: [2]uint32{1, 2},
		d: [2]int16{1, 2},
		e: [2]int32{1, 2},
	}
}

//go:noinline
func moves() {
	Sink.a = Source.a
	Sink.b = Source.b
	Sink.c = Source.c
	Sink.d = Source.d
	Sink.e = Source.e
}

//go:noinline
func loads() *T {
	t := newT()
	t.a = Source.a
	t.b = Source.b
	t.c = Source.c

        m.region(pos, input.length());
        return m.lookingAt();
    }

    public String region() {
        return input.substring(markPos, pos);
    }

    /**
     * Moves the position to the next instance of the given character, or the end of the input if not found.
     */
    public void find(char c) {
        int cpos = pos;
        while (cpos < input.length()) {

}

// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *List) MoveToFront(e *Element) {
	if e.list != l || l.root.next == e {
		return
	}
	// see comment in List.Remove about initialization of l
	l.move(e, &l.root)
}

// MoveToBack moves element e to the back of list l.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package codegen

import "runtime"

// Check small copies are replaced with moves.

func movesmall4() {
	x := [...]byte{1, 2, 3, 4}
	// 386:-".*memmove"
	// amd64:-".*memmove"
	// arm:-".*memmove"
	// arm64:-".*memmove"
	// ppc64x:-".*memmove"
	copy(x[1:], x[:])
}

// run

// Test for 8g register move bug.  The optimizer gets confused
// about 16- vs 32-bit moves during splitContractIndex.

// Issue 3910.

package main

func main() {
	const c = 0x12345678
	index, n, offset := splitContractIndex(c)
	if index != int((c&0xffff)>>5) || n != int(c&(1<<5-1)) || offset != (c>>16)&(1<<14-1) {
		println("BUG", index, n, offset)
	}
}

func splitContractIndex(ce uint32) (index, n, offset int) {

// run

// Test for 6g register move bug.  The optimizer gets confused
// about 32- vs 64-bit moves during splitContractIndex.

// Issue 3918.

package main

func main() {
	const c = 0x123400005678
	index, offset := splitContractIndex(c)
	if index != (c&0xffffffff)>>5 || offset != c+1 {
		println("BUG", index, offset)
	}
}

func splitContractIndex(ce uint64) (index uint32, offset uint64) {
	h := uint32(ce)

    /**
     * @deprecated do not use outside of this class
     */
    @Deprecated
    public static InstrumentedInputsListener listener() {
        // TODO(mlopatkin): Reduce the visibility of this method once everything moves into this project.
        return LISTENER.get();
    }

    public static void setListener(InstrumentedInputsListener listener) {
        LISTENER.set(listener);
    }

    public static void discardListener() {

    implementation(libs.julToSlf4j)
    implementation(libs.commonsLang)
    implementation(libs.commonsIo)
    implementation(libs.guava)

    // GSon is not strictly required here but removing it moves the dependency in the distribution from lib to lib/plugins
    // TODO Check if this is an issue
    runtimeOnly(libs.gson)
    runtimeOnly(libs.jclToSlf4j)
    runtimeOnly(libs.log4jToSlf4j)