r0 -= d
	}
	return Word(qq), Word(r0 >> s)
}

// reciprocalWord return the reciprocal of the divisor. rec = floor(( _B^2 - 1 ) / u - _B). u = d1 << nlz(d1).
func reciprocalWord(d1 Word) Word {
	u := uint(d1 << nlz(d1))
	x1 := ^u
	x0 := uint(_M)
	rec, _ := bits.Div(x1, x0, u) // (_B^2-1)/U-_B = (_B*(_M-C)+_M)/U
	return Word(rec)

  // CHECK-LABEL: func @annotate_broadcast_values
  func.func @annotate_broadcast_values(%arg0: tensor<?xi32>) -> tensor<?xi32> {
    %0 = "tf._A"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>
    %1 = "tf._B"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>
    %5:2 = tf_device.replicate([%0, %arg0] as %ri_0: tensor<?xi32>) {n = 2 : i32} {
      %2 = "tf._F"(%arg0) : (tensor<?xi32>) -> tensor<?xi32>

)

// Test deduping and extended sorting
import (
	"B" // B
	a "A" // aA
	b "A" // bA2
	b "A" // bA1
	. "B" // .B
	. "B"
	"C"
	"C"
	"C"
	a "D" // aD
	"B"
	_ "B" // _b
)

import (
	"dedup_by_group"
	"dedup_by_group"

	"dedup_by_group"
)

import (
	/* comment */ io1 "io"
	"fmt" // for Printf
	/* comment */ "log"
	/* comment */ io2 "io"
)

	"io"  // for Reader
	"log" // for Fatal
	"math"
)

// Test deduping and extended sorting
import (
	a "A" // aA
	b "A" // bA1
	b "A" // bA2
	"B"   // B
	. "B" // .B
	_ "B" // _b
	"C"
	a "D" // aD
)

import (
	"dedup_by_group"

	"dedup_by_group"
)

import (
	"fmt" // for Printf
	/* comment */ io1 "io"
	/* comment */ io2 "io"
	/* comment */ "log"

			t.Errorf("#%d: out in table=0x%s, computed=0x%s", i, out.utoa(16), p.abs.norm().utoa(16))
		}

		// check k0 in table
		k := new(Int).Mod(&Int{abs: m}, _B)
		k = new(Int).Sub(_B, k)
		k = new(Int).Mod(k, _B)
		k0 := Word(new(Int).ModInverse(k, _B).Uint64())
		if k0 != Word(test.k0) {
			t.Errorf("#%d: k0 in table=%#x, computed=%#x\n", i, test.k0, k0)
		}

        'A ( <include.h> )'                                | 'A'     | [expression('<include.h>')]
        'A ( _b )'                                         | 'A'     | [token('_b')]
        'A ( _b(c) )'                                      | 'A'     | [expression('_b(c)')]

        def e = thrown(IllegalArgumentException)
        e.message == "Identity may contain only letters and digits, received: $identity"

        where:
        identity << ['%$#$#^!@', '', ' ', 'a ', 'a b', '$a', '_b', 'c!', '-42', null]
    }

    def "describes missing properties"() {
        given:
        providerFactory.gradleProperty('myServiceUsername') >> Providers.notDefined()

		case AMOVD:
			if i2&1 != 0 {
				zRIL(_b, op_LARL, regtmp(p), 0, asm)
				zRXY(op_LG, uint32(p.To.Reg), regtmp(p), 0, 1, asm)
				i2 -= 1
			} else {
				zRIL(_b, op_LGRL, uint32(p.To.Reg), 0, asm)
			}
		case AMOVW:
			zRIL(_b, op_LGFRL, uint32(p.To.Reg), 0, asm)
		case AMOVWZ:
			zRIL(_b, op_LLGFRL, uint32(p.To.Reg), 0, asm)
		case AMOVH:
			zRIL(_b, op_LGHRL, uint32(p.To.Reg), 0, asm)
		case AMOVHZ:

		"a.abc*",
		"a.b.*",
		"a/b/c/d",
		"a/*",
		"a/b/*",
		"a.b/c*",
		"a.b/c.d",
		"a/b.c/d",
	}
	invalid := []string{
		"",
		"ä",
		"a_",
		"_",
		"_a",
		"_a._b",
		"__",
		"-",
		".",
		"a.",
		".a",
		"a.b.",
		"a*.b",
		"a*b",
		"*a",
		"Abc",
		"/",
		"a/",
		"/a",
		"a*/b",
		func(n int) string {
			x := make([]byte, n)

            "c": dependentSet(false, [], []),
            "d": dependentSet(false, ["e"], []),
            "e": dependentSet(false, [], [])
        ])
        /*
        Class a {
            private b _b;
        }
        Class b {
            private c _c;
            public d _d;
        }
        Class c {
        }
        Class d {
            private e _e;
        }
        Class e {
        }