Goto("b3")),
		Bloc("b3",
			Valu("phi2", OpPhi, c.config.Types.Bool, 0, nil, "cmp1", "cmp2"),
			If("phi2", "b4", "b5")),
		Bloc("b4",
			Valu("cmp3", OpLess64, c.config.Types.Bool, 0, nil, "arg3", "arg1"),
			Goto("b5")),
		Bloc("b5",
			Valu("phi3", OpPhi, c.config.Types.Bool, 0, nil, "phi2", "cmp3"),
			If("phi3", "b6", "b7")),
		Bloc("b6",
			Exit("mem")),
		Bloc("b7",
			Exit("mem")))

	return s[len(s)-1]
}

func (s sorted) quantile(phi float64) float64 {
	if len(s) == 0 || math.IsNaN(phi) {
		return nan
	}
	if phi <= 0 {
		return s.min()
	}
	if phi >= 1 {
		return s.max()
	}
	idx := uint(phi*float64(len(s)-1) + 0.5)
	if idx >= uint(len(s)) {
		idx = uint(len(s) - 1)
	}
	return s[idx]
}

func (s sorted) quantiles(phis ...float64) []float64 {

		}
	}
}

// phielim eliminates redundant phi values from f.
// A phi is redundant if its arguments are all equal. For
// purposes of counting, ignore the phi itself. Both of
// these phis are redundant:
//
//	v = phi(x,x,x)
//	v = phi(x,v,x,v)
//
// We repeat this process to also catch situations like:
//
//	v = phi(x, phi(x, x), phi(x, v))
//
// TODO: Can we also simplify cases like:
//

		u = int32(data2[20])
		v = int32(data2[21])
		w = int32(data2[22])
		x = int32(data2[23])
		y = int32(data2[24])
		z = int32(data2[25])
	}
	// Lots of phis of the form phi(int32,int64) of type int32 happen here.
	// Some will be stack phis. For those stack phis, make sure the spill
	// of the second argument uses the phi's width (4 bytes), not its width
	// (8 bytes).  Otherwise, a random stack slot gets clobbered.

	// Adjust c.Preds
	c.removePred(j)

	// Remove phi args from c's phis.
	for _, v := range c.Values {
		if v.Op != OpPhi {
			continue
		}
		c.removePhiArg(v, j)
		// Note: this is trickier than it looks. Replacing
		// a Phi with a Copy can in general cause problems because
		// Phi and Copy don't have exactly the same semantics.
		// Phi arguments always come from a predecessor block,

//  1. The start memory state of a block is InitMem, a Phi node of type mem or
//     an incoming memory value.
//  2. The start memory state of a block is consistent with the end memory state
//     of its parent nodes. If the start memory state of a block is a Phi value,
//     then the end memory state of its parent nodes is consistent with the
//     corresponding argument value of the Phi node.

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ssa

// phiopt eliminates boolean Phis based on the previous if.
//
// Main use case is to transform:
//
//	x := false
//	if b {
//	  x = true
//	}
//
// into x = b.
//
// In SSA code this appears as
//
//	b0
//	  If b -> b1 b2
//	b1

			for _, v := range b.Values {
				p.value(v, live[v.ID])
				printed[v.ID] = true
			}
			p.endBlock(b, reachable[b.ID])
			continue
		}

		// print phis first since all value cycles contain a phi
		n := 0
		for _, v := range b.Values {
			if v.Op != OpPhi {
				continue
			}
			p.value(v, live[v.ID])
			printed[v.ID] = true
			n++
		}

				s.Pos = s.Pos.WithIsStmt()
			}
		}
		// If `s` had more than one predecessor, update its phi-ops to
		// account for the merge.
		if ns > 1 {
			for _, v := range s.Values {
				if v.Op == OpPhi {
					mergePhi(v, j, b)
				}

			}
			// Remove the phi-ops from `b` if they were merged into the
			// phi-ops of `s`.
			k := 0
			for _, v := range b.Values {
				if v.Op == OpPhi {
					if v.Uses == 0 {

			continue
		}

		var phi *Value
		// determine if we've only got a single phi in this
		// block, this is easier to handle than the general
		// case of a block with multiple phi values.
		for _, v := range b.Values {
			if v.Op == OpPhi {
				if phi != nil {
					phi = nil
					break
				}
				phi = v
			}
		}

		// reset our block map
		if phi != nil {
			for _, v := range phi.Args {