// license that can be found in the LICENSE file.

package bug

func example(n int) (rc int) {
	var cc, ll, pp, rr [27]int
	for q0 := 0; q0 < n-2; q0++ {
		for q1 := q0 + 2; q1 < n; q1++ {
			var c, d, l, p, r int
			b0 := 1 << uint(q0)
			b1 := 1 << uint(q1)
			l = ((b0 << 1) | b1) << 1
			c = b0 | b1 | (-1 << uint(n))
			r = ((b0 >> 1) | b1) >> 1
		E:
			if c != -1 {
				p = ^(l | c | r)

		x int
	}
	type Q2 *S1
	var q0 *struct {
		x int
	}
	var q1 Q1
	var q2 Q2
	var ps1 *S1
	q0 = q0
	q0 = q1
	q0 = (*struct {
		x int
	})(ps1) // legal because of special conversion exception for pointers
	q0 = (*struct {
		x int
	})(q2) // ERROR "cannot|invalid"
	q1 = q0
	q1 = q1
	q1 = Q1(q2)    // ERROR "cannot|invalid"

GraphDef BuildDoubleQueueGraph() {
  Scope root = Scope::NewRootScope();
  auto q0 = FIFOQueue(root.WithOpName(kQueueName0), {DataType::DT_INT32});
  auto ten = Const(root, 10);
  auto enqueue0 = QueueEnqueue(root.WithOpName(kEnqueueOp0), q0, {ten});
  auto close0 = QueueClose(root.WithOpName(kCloseOp0), q0);
  auto cancel0 = QueueClose(root.WithOpName(kCancelOp0), q0,
                            QueueClose::CancelPendingEnqueues(true));

    j1 = normalize(list(yaml.safe_load_all(open(args.new))), args)

    q0 = {by_resource_name(res): res for res in j0 if res is not None}
    q1 = {by_resource_name(res): res for res in j1 if res is not None}

    added, removed, common = keydiff(q0.keys(), q1.keys())

    changed = 0
    for k in sorted(common):
        if q0[k] != q1[k]:
            changed += 1

    print("## +++ ", args.new)

  func.return %0 : tensor<2x2xf32>

// CHECK: %[[q0:.*]] = "tfl.quantize"(%arg1) <{qtype = tensor<2x1x!quant.uniform<u8:f32, 0.0078431372549019607:128>>}>
// CHECK: %[[q1:.*]] = "tfl.quantize"(%arg0) <{qtype = tensor<2x2x!quant.uniform<u8:f32, 0.0078431372549019607:128>>}>
// Quantized tfl.add

    func.return %a: tensor<*xf32>
  }
}

// CHECK-LABEL: same_scale_ptq_test

// CHECK: %[[q0:.*]] = "quantfork.qcast"(%arg0)
// CHECK: %[[dq0:.*]] = "quantfork.dcast"(%[[q0]])
// CHECK-SAME: quant.uniform<i8:f32, 0.010039215461880554:-1>
// CHECK: %[[maxpool:.*]] = "tf.MaxPool"(%[[dq0]])
// CHECK: %[[q1:.*]] = "quantfork.qcast"(%[[maxpool]])

		rhat += vn1
		if rhat < b {
			goto again1
		}
	}

	un21 := un32*b + un1 - q1*v
	q0 := un21 / vn1
	rhat = un21 - q0*vn1

again2:
	if q0 >= b || q0*vn0 > b*rhat+un0 {
		q0--
		rhat += vn1
		if rhat < b {
			goto again2
		}
	}

	return q1*b + q0, (un21*b + un0 - q0*v) >> s
}

func fadd32(x, y uint32) uint32 {
	return f64to32(fadd64(f32to64(x), f32to64(y)))
}

	const (
		P0 = -0.6307673640497716991184787251e+6
		P1 = -0.8991272022039509355398013511e+5
		P2 = -0.2894211355989563807284660366e+4
		P3 = -0.2630563213397497062819489e+2
		Q0 = -0.6307673640497716991212077277e+6
		Q1 = 0.1521517378790019070696485176e+5
		Q2 = -0.173678953558233699533450911e+3
	)

	sign := false
	if x < 0 {
		x = -x
		sign = true
	}

	var temp float64

// CHECK-DAG: %[[cst_1:.*]] = arith.constant dense<{{.*}}> : tensor<2x3x3x2xf32>

// CHECK: %[[q0:.*]] = "quantfork.qcast"(%[[cst]]) {volatile}
// CHECK-SAME: tensor<2x!quant.uniform<i32:f32:0, {0.044169864606680966,0.042867627733627671}>>
// CHECK: %[[dq0:.*]] = "quantfork.dcast"(%[[q0]])

// CHECK: %[[q1:.*]] = "quantfork.qcast"(%[[cst_1]]) {volatile}

    // CHECK: %[[Q0:.*]] = "quantfork.qcast"(%[[CST0]])
    // CHECK: %[[Q1:.*]] = "quantfork.qcast"(%[[CST1]])
    // CHECK: %[[Q2:.*]] = "quantfork.qcast"(%[[ARG0]])
    // CHECK: %[[CALL:.*]] = call @quantized_dot_general_fn_1(%[[Q2]], %[[Q1]])

    // CHECK: %[[REDUCE:.*]] = "stablehlo.reduce_window"(%[[CALL]], %[[Q0]])