// CHECK:           %[[TPOS:.*]] = stablehlo.transpose %[[REDUCE]], dims = [0, 3, 1, 2]
// CHECK:              : (tensor<1x56x56x64xf32>) -> tensor<1x64x56x56xf32>
// CHECK:           return %[[TPOS]] : tensor<1x64x56x56xf32>

func.func @commute_transpose_reduce_window(
      %input: tensor<1x114x114x64xf32>,
      %cst: tensor<f32>) -> tensor<1x64x56x56xf32> {
  %tpos = stablehlo.transpose %input, dims = [0, 3, 1, 2]

		if bz2.repeats > 0 {
			buf[n] = byte(bz2.lastByte)
			n++
			bz2.repeats--
			if bz2.repeats == 0 {
				bz2.lastByte = -1
			}
			continue
		}

		bz2.tPos = bz2.preRLE[bz2.tPos]
		b := byte(bz2.tPos)
		bz2.tPos >>= 8
		bz2.preRLEUsed++

		if bz2.byteRepeats == 3 {
			bz2.repeats = uint(b)
			bz2.byteRepeats = 0
			continue
		}

		if bz2.lastByte == int(b) {

	fmt.Fprintf(w, "\tCount     [%d]uint32\n", len(f.blocks))
	fmt.Fprintf(w, "\tPos       [3 * %d]uint32\n", len(f.blocks))
	fmt.Fprintf(w, "\tNumStmt   [%d]uint16\n", len(f.blocks))
	fmt.Fprintf(w, "} {\n")

	// Initialize the position array field.
	fmt.Fprintf(w, "\tPos: [3 * %d]uint32{\n", len(f.blocks))

	// A nice long list of positions. Each position is encoded as follows to reduce size:

func CheckEqNNN_TTT() {
	onesA := [NNN]ttt{ONES}
	onesB := [NNN]ttt{ONES}
	twos := [NNN]ttt{TWOS}
	if onesA != onesB {
		println("onesA != onesB in CheckEqNNN_TTT")
	}
	if onesA == twos {
		println("onesA == twos in CheckEqNNN_TTT")
	}
	if onesB == twos {
		println("onesB == twos in CheckEqNNN_TTT")
	}
	if s := fmt.Sprint(onesA == onesB, onesA != twos, onesB != twos); s != "true true true" {
		println("fail in CheckEqNNN_TTT:", s)
	}
}

		print("Ones: ")
		printn(Ones, 10)
		print("Twos: ")
		printn(Twos, 10)
		print("Add: ")
		printn(Add(Ones, Twos), 10)
		print("Diff: ")
		printn(Diff(Ones), 10)
		print("Integ: ")
		printn(Integ(zero, Ones), 10)
		print("CMul: ")
		printn(Cmul(neg(one), Ones), 10)
		print("Sub: ")
		printn(Sub(Ones, Twos), 10)
		print("Mul: ")
		printn(Mul(Ones, Ones), 10)
		print("Exp: ")

		print("Ones: ")
		Printn(Ones, 10)
		print("Twos: ")
		Printn(Twos, 10)
		print("Add: ")
		Printn(Add(Ones, Twos), 10)
		print("Diff: ")
		Printn(Diff(Ones), 10)
		print("Integ: ")
		Printn(Integ(zero, Ones), 10)
		print("CMul: ")
		Printn(Cmul(neg(one), Ones), 10)
		print("Sub: ")
		Printn(Sub(Ones, Twos), 10)
		print("Mul: ")
		Printn(Mul(Ones, Ones), 10)
		print("Exp: ")

            new TarOutputStream(it).withCloseable { TarOutputStream tos ->
                TarEntry entry = new TarEntry('../../tmp/evil.sh')
                byte[] bytes = 'evil'.getBytes('utf-8')
                entry.size = bytes.length
                tos.putNextEntry(entry)
                tos.write(bytes)
                tos.closeEntry()
            }
        }
    }

func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()
	for tok == scanner.EOF && len(s.tr) > 1 {
		tos.Close()
		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

			tos = tos.prev

		default:
			// Push
			tos = &stackEnt{s.Name, val, 0, tos}
		}
	}

	if tos == noPath {
		return "", 0
	}
	return tos.path, aline - tos.start - tos.offset + 1
}

func (o *Obj) alineFromLine(path string, line int) (int, error) {
	if line < 1 {
		return 0, &UnknownLineError{path, line}
	}

	for i, s := range o.Paths {
		// Find this path

func (g *Graph) Transpose() {
	old := g.edges

	g.edges = make(map[string]map[string]bool)
	for _, n := range g.Nodes {
		g.edges[n] = make(map[string]bool)
	}

	for from, tos := range old {
		for to := range tos {
			g.edges[to][from] = true
		}
	}
}

// Topo returns a topological sort of g. This function is deterministic.
func (g *Graph) Topo() []string {
	topo := make([]string, 0, len(g.Nodes))