ip6tables -t nat -A ISTIO_IN_REDIRECT -p tcp -j REDIRECT --to-ports 15006
ip6tables -t nat -A PREROUTING -p tcp -j ISTIO_INBOUND
ip6tables -t nat -A ISTIO_INBOUND -p tcp --dport 4000 -j ISTIO_IN_REDIRECT
ip6tables -t nat -A ISTIO_INBOUND -p tcp --dport 5000 -j ISTIO_IN_REDIRECT
ip6tables -t nat -A OUTPUT -p tcp -j ISTIO_OUTPUT
ip6tables -t nat -A ISTIO_OUTPUT -o lo -s ::6/128 -j RETURN

time this becomes just

	<a my:data-href="{{. | attrescaper}}"></a>

As a special case, attributes with the namespace "xmlns" are always treated
as containing URLs. Given the excerpts

	<a xmlns:title="{{.}}"></a>
	<a xmlns:href="{{.}}"></a>
	<a xmlns:onclick="{{.}}"></a>

At parse time they become:

	<a xmlns:title="{{. | urlescaper | attrescaper}}"></a>
	<a xmlns:href="{{. | urlescaper | attrescaper}}"></a>

iptables -t nat -A ISTIO_OUTPUT -m owner --gid-owner 2 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -p tcp --dport 53 -d 127.0.0.53/32 -j REDIRECT --to-ports 15053
iptables -t nat -A ISTIO_OUTPUT -d 127.0.0.1/32 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -d 1.1.0.0/16 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -d 9.9.0.0/16 -j ISTIO_REDIRECT
iptables -t nat -A OUTPUT -p udp -j ISTIO_OUTPUT
iptables -t raw -A OUTPUT -p udp -j ISTIO_OUTPUT

# (including the specific case where P has no test files).
go test -coverpkg=./a ./...
stdout '^ok\s+M/a\s+\S+\s+coverage: 100.0% of statements in ./a'
stdout '^\s*\?\s+M/f\s+\[no test files\]'

-- a/a.go --
package a

import "M/f"

var G int

func AFunc() int {
	G = 1
	return f.Id()
}
-- a/a_test.go --
package a

import "testing"

func TestA(t *testing.T) {
	if AFunc() != 42 {

ip6tables -t nat -A ISTIO_INBOUND -p tcp --dport 15008 -j RETURN
ip6tables -t nat -A ISTIO_REDIRECT -p tcp -j REDIRECT --to-ports 15001
ip6tables -t nat -A ISTIO_IN_REDIRECT -p tcp -j REDIRECT --to-ports 15006
ip6tables -t nat -A PREROUTING -p tcp -j ISTIO_INBOUND
ip6tables -t nat -A ISTIO_INBOUND -p tcp --dport 4000 -j ISTIO_IN_REDIRECT
ip6tables -t nat -A ISTIO_INBOUND -p tcp --dport 5000 -j ISTIO_IN_REDIRECT

        0 * function._
    }

    def "can get entries"() {
        def a = new Object()
        def b = new Object()
        def function = Mock(Function)

        given:
        function.apply("a") >> a

        def cache = newCache()
        cache.get("a", function)
        cache.put("b", b)

        expect:
        cache.getIfPresent("a") == a
        cache.getIfPresent("b") == b

iptables -t nat -N ISTIO_OUTPUT
iptables -t raw -N ISTIO_OUTPUT
iptables -t nat -A ISTIO_INBOUND -p tcp --dport 15008 -j RETURN
iptables -t nat -A ISTIO_REDIRECT -p tcp -j REDIRECT --to-ports 15001
iptables -t nat -A ISTIO_IN_REDIRECT -p tcp -j REDIRECT --to-ports 15006
iptables -t nat -A OUTPUT -p tcp -j ISTIO_OUTPUT
iptables -t nat -A ISTIO_OUTPUT -o lo -s 127.0.0.6/32 -j RETURN

	{`^...$`, true},
	{`^(?:a|(?:aa))$`, true},
	{`^a((b))c$`, true},
	{`^a.[l-nA-Cg-j]?e$`, true},
	{`^a((b))$`, true},
	{`^a(?:(b)|(c))c$`, true},
	{`^a(?:(b*)|(c))c$`, false},
	{`^a(?:b|c)$`, true},
	{`^a(?:b?|c)$`, true},
	{`^a(?:b?|c?)$`, false},
	{`^a(?:b?|c+)$`, true},
	{`^a(?:b+|(bc))d$`, false},
	{`^a(?:bc)+$`, true},
	{`^a(?:[bcd])+$`, true},
	{`^a((?:[bcd])+)$`, true},

   *     accepts a cause: Users of this class typically expect for instances to have a non-null
   *     cause. At the moment, you can <i>usually</i> still preserve behavior by passing an explicit
   *     {@code null} cause. Note, however, that passing an explicit {@code null} cause prevents
   *     anyone from calling {@link #initCause} later, so it is not quite equivalent to using a

			nodeIndex = r
		}

		if nodeIndex == invalidNodeValue {
			// We found a leaf. Use the value of bit to decide
			// whether is a left or a right value.
			l, r := node.leftValue, node.rightValue
			if bit == 1 {
				v = l
			} else {
				v = r
			}
			return
		}
	}
}

// newHuffmanTree builds a Huffman tree from a slice containing the code
// lengths of each symbol. The maximum code length is 32 bits.