var x195 [10<<20]byte
	var x196 [10<<20]byte
	var x197 [10<<20]byte
	var x198 [10<<20]byte
	var x199 [10<<20]byte
	var x200 [10<<20]byte
	var x201 [10<<20]byte
	var x202 [10<<20]byte
	var x203 [10<<20]byte
	var x204 [10<<20]byte
	var x205 [10<<20]byte
	var x206 [10<<20]byte
	var x207 [10<<20]byte
	z = x1
	z = x2
	z = x3
	z = x4
	z = x5
	z = x6
	z = x7
	z = x8
	z = x9
	z = x10

	var x200 uint64
	var x201 uint64
	x200, x201 = bits.Add64(x188, uint64(0x0), uint64(p384Uint1(x199)))
	var x202 uint64
	_, x202 = bits.Mul64(x190, 0x100000001)
	var x204 uint64
	var x205 uint64
	x205, x204 = bits.Mul64(x202, 0xffffffffffffffff)
	var x206 uint64
	var x207 uint64
	x207, x206 = bits.Mul64(x202, 0xffffffffffffffff)
	var x208 uint64
	var x209 uint64

	var x200 uint64
	p224CmovznzU64(&x200, p224Uint1(x199), x190, x181)
	var x201 uint64
	p224CmovznzU64(&x201, p224Uint1(x199), x192, x183)
	var x202 uint64
	p224CmovznzU64(&x202, p224Uint1(x199), x194, x185)
	var x203 uint64
	p224CmovznzU64(&x203, p224Uint1(x199), x196, x187)
	out1[0] = x200
	out1[1] = x201
	out1[2] = x202
	out1[3] = x203
}

	var x200 uint64
	var x201 uint64
	x200, x201 = bits.Add64(x145, x181, uint64(p521Uint1(x199)))
	var x202 uint64
	var x203 uint64
	x202, x203 = bits.Add64(x147, x183, uint64(p521Uint1(x201)))
	var x204 uint64
	var x205 uint64
	x204, x205 = bits.Add64(x149, x185, uint64(p521Uint1(x203)))
	var x206 uint64
	var x207 uint64
	x206, x207 = bits.Add64(x151, x187, uint64(p521Uint1(x205)))

    X195,
    X196,
    X197,
    X198,
    X199,
    X200,
    X201,
    X202,
    X203,
    X204,
    X205,
    X206,
    X207,
    X208,
    X209,
    X210,
    X211,
    X212,
    X213,
    X214,
    X215,
    X216,
    X217,
    X218,
    X219,
    X220,
    X221,
    X222,
    X223,
    X224,
    X225,
    X226,
    X227,

    X195,
    X196,
    X197,
    X198,
    X199,
    X200,
    X201,
    X202,
    X203,
    X204,
    X205,
    X206,
    X207,
    X208,
    X209,
    X210,
    X211,
    X212,
    X213,
    X214,
    X215,
    X216,
    X217,
    X218,
    X219,
    X220,
    X221,
    X222,
    X223,
    X224,
    X225,
    X226,
    X227,

			set: &utilipset.IPSet{
				Name: "abz",
			},
			setType:         utilipset.HashIPPort,
			ipv6:            true,
			activeEntries:   []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
			currentEntries:  []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
			expectedEntries: []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
		},
		{
			name: "ipset sync with updated udp->tcp in hash",
			set: &utilipset.IPSet{
				Name: "bca",
			},

			panic("testLargeOffset: index mismatch")
		}
	}

	x := globallib.Data[1<<20+1]
	if x != 1<<20+1 {
		panic("testLargeOffset: direct mismatch")
	}

	y := &globallib.Data[1<<20+2]
	if y != &ptrData()[1<<20+2] {
		panic("testLargeOffset: address mismatch")
	}
}

func main() {
	testLoop()

	// SSA rules commonly merge offsets into addresses. These

package windows_test

import (
	"errors"
	"internal/syscall/windows"
	"syscall"
	"testing"
)

func TestSupportUnixSocket(t *testing.T) {
	var d syscall.WSAData
	if err := syscall.WSAStartup(uint32(0x202), &d); err != nil {
		t.Fatal(err)
	}
	defer syscall.WSACleanup()

	// Test that SupportUnixSocket returns true if WSASocket succeeds with AF_UNIX.
	got := windows.SupportUnixSocket()

            port:
              number: 4201
      # With a trailing /
      - path: /sub/path/
        backend:
          service:
            name: service1
            port:
              number: 4202
      # Regex ending with .*
      - path: /regex1.*
        backend:
          service:
            name: service1
            port:
              number: 4203
      # Regex ending with *