})
	}
	return zs, nil
}

func main() {
	flag.Parse()
	zs, err := readWindowsZones()
	if err != nil {
		log.Fatal(err)
	}
	slices.SortFunc(zs, func(a, b *zone) int {
		return strings.Compare(a.UnixName, b.UnixName)
	})
	var v = struct {
		URL string
		Zs  []*zone
	}{
		wzURL,
		zs,
	}
	var buf bytes.Buffer
	err = template.Must(template.New("prog").Parse(prog)).Execute(&buf, v)

	pe -= int32(is62zero)

	// Swap addition operands so |p| >= |z|
	if pe < ze || pe == ze && pm1 < zm1 {
		ps, pe, pm1, pm2, zs, ze, zm1, zm2 = zs, ze, zm1, zm2, ps, pe, pm1, pm2
	}

	// Special case: if p == -z the result is always +0 since neither operand is zero.
	if ps != zs && pe == ze && pm1 == zm1 && pm2 == zm2 {
		return 0
	}

	// Align significands
	zm1, zm2 = shrcompress(zm1, zm2, uint(pe-ze))

	}
}

// test static variable conversion

var (
	ss  = make([]string, 10)
	s5  = (*[5]string)(ss)
	s10 = (*[10]string)(ss)

	ns  []string
	ns0 = (*[0]string)(ns)

	zs  = make([]string, 0)
	zs0 = (*[0]string)(zs)
)

func init() {
	if &ss[0] != &s5[0] {
		panic("s5 conversion failed")
	}
	if &ss[0] != &s10[0] {
		panic("s5 conversion failed")
	}
	if ns0 != nil {

	pLo    = pLl | pLu // a letter that is neither upper nor lower case.
	pLmask = pLo
)

// GraphicRanges defines the set of graphic characters according to Unicode.
var GraphicRanges = []*RangeTable{
	L, M, N, P, S, Zs,
}

// PrintRanges defines the set of printable characters according to Go.
// ASCII space, U+0020, is handled separately.
var PrintRanges = []*RangeTable{
	L, M, N, P, S,
}

    public static final Pattern LUCENE_FIELD_RESERVED_PATTERN = Pattern.compile("([+\\-!\\(\\){}\\[\\]^\"~\\\\:\\p{Zs}]|(&&)|(\\|\\|))"); // "*", "?",

    public static final Pattern LUCENE_RANGE_FIELD_RESERVED_PATTERN = Pattern.compile("([!\\(\\){}\\[\\]\"~\\\\:\\p{Zs}]|(&&)|(\\|\\|))");

    public static final String SEARCH_LOG_ACCESS_TYPE = "searchLogAccessType";

                extention = strings[strings.length - 1];
            } else {
                filePrefix = name;
                extention = "";
            }
            filePrefix = filePrefix.replaceAll("\\p{Zs}", "_");
        } else {
            filePrefix = "none";
            extention = "";
        }
        File inputFile = null;
        File outputFile = null;
        try {

					in = append([]byte{}, orig...)
					writeAndKill(c, in)
					c.Close()
					diffJSON(t, buf.Bytes(), want)
				})
			}
		})
	}
}

// writeAndKill writes b to w and then fills b with Zs.
// The filling makes sure that if w is holding onto b for
// future use, that future use will have obviously wrong data.
func writeAndKill(w io.Writer, b []byte) {
	w.Write(b)
	for i := range b {
		b[i] = 'Z'
	}

00000230  4f 0b 2b b5 16 68 dc 25  42 b5 0b f7 13 6a c5 81  |O.+..h.%B....j..|
00000240  c0 18 bc fb 40 86 cc 99  2e 70 2b 9a 72 eb be 57  |....@....p+.r..W|
00000250  a0 43 92 83 3b 7e c8 02  43 ab 17 7a 73 87 1a a2  |.C..;~..C..zs...|
00000260  1c 01 db b4 31 b1 d9 44  f1 c0 d9 de 27 bd 4c 8b  |....1..D....'.L.|
00000270  1c f5 3d db d6 aa 98 7d  43 fe dd 64 85 8b c1 88  |..=....}C..d....|

00000270  95 12 07 8f 2a 16 03 03  00 b6 0c 00 00 b2 03 00  |....*...........|
00000280  1d 20 04 b4 79 b4 2c 1d  0f b3 4b ff 67 e7 24 88  |. ..y.,...K.g.$.|
00000290  d6 db 4f 1e 66 da 0e f2  89 5a 53 ed 4e ba ad 4c  |..O.f....ZS.N..L|
000002a0  81 0a 04 03 00 8a 30 81  87 02 42 01 fb 16 53 43  |......0...B...SC|
000002b0  2b 86 61 0a 58 a0 68 c1  cd 2c ff ec 79 7f 83 fa  |+.a.X.h..,..y...|

00000020  c9 7f 00 78 9b a3 b2 1b  ef 43 66 20 07 97 7c a6  |...x.....Cf ..|.|
00000030  9b c6 a9 47 42 ae 99 bf  59 fe 52 f6 da d9 1c 68  |...GB...Y.R....h|
00000040  c2 7a 53 3f 27 0d 11 87  9a 47 81 5c c0 13 00 00  |.zS?'....G.\....|
00000050  11 ff 01 00 01 00 00 0b  00 04 03 00 01 02 00 17  |................|
00000060  00 00 16 03 01 02 59 0b  00 02 55 00 02 52 00 02  |......Y...U..R..|