// a call to [Cond.Broadcast] or [Cond.Signal] “synchronizes before” any Wait call
// that it unblocks.
//
// For many simple use cases, users will be better off using channels than a
// Cond (Broadcast corresponds to closing a channel, and Signal corresponds to
// sending on a channel).
//
// For more on replacements for [sync.Cond], see [Roberto Clapis's series on

func (p *PushQueue) Pending() int {
	p.cond.L.Lock()
	defer p.cond.L.Unlock()
	return len(p.queue)
}

// ShutDown will cause queue to ignore all new items added to it. As soon as the
// worker goroutines have drained the existing items in the queue, they will be
// instructed to exit.
func (p *PushQueue) ShutDown() {
	p.cond.L.Lock()
	defer p.cond.L.Unlock()
	p.shuttingDown = true
	p.cond.Broadcast()

func.func @set_stateless(%arg: tensor<i32>, %cond: tensor<i1>) -> (tensor<i32>, tensor<i32>) {
  // CHECK: tf.While
  // CHECK-SAME: is_stateless = true
  %0 = "tf.While"(%arg) { cond = @no_side_effect_cond, body = @no_side_effect_body, is_stateless = false} : (tensor<i32>) -> (tensor<i32>)
  // CHECK: tf.If
  // CHECK-SAME: is_stateless = true

fun test() {
    outer@ while (cond()) {
        consume(1)
        while (cond()) {
            consume(2)
            <expr>if (cond()) {
                break
            } else if (cond()) {
                break@outer
            }</expr>
        }
    }
}

fun consume(obj: Any?) {}

		return nil
	}

	// check old condition
	cond := calculateCondition(inCustomResourceDefinition)
	old := apiextensionshelpers.FindCRDCondition(inCustomResourceDefinition, apiextensionsv1.NonStructuralSchema)

	if cond == nil && old == nil {
		return nil
	}
	if cond != nil && old != nil && old.Status == cond.Status && old.Reason == cond.Reason && old.Message == cond.Message {
		return nil
	}

	// update condition

    }
  }
}
node {
  name: "cond/Switch"
  op: "Switch"
  input: "Placeholder_1"
  input: "Placeholder_1"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "cond/switch_t"
  op: "Identity"
  input: "cond/Switch:1"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
}
node {
  name: "cond/switch_f"
  op: "Identity"

        type: DT_FLOAT
      }
    }
  }
  attr {
    key: "body"
    value {
      func {
        name: "body"
      }
    }
  }
  attr {
    key: "cond"
    value {
      func {
        name: "cond"
      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "StatelessWhile"
  op: "StatelessWhile"
  input: "iter"
  input: "val"
  attr {
    key: "T"

		initialSync: atomic.NewBool(false),
		cond:        sync.NewCond(&sync.Mutex{}),
		id:          name,
		metrics:     newQueueMetrics(name),
	}
}

func (q *queueImpl) Push(item Task) {
	q.cond.L.Lock()
	defer q.cond.L.Unlock()
	if !q.closing {
		q.tasks = append(q.tasks, &queueTask{task: item, enqueueTime: time.Now()})
		q.metrics.depth.RecordInt(int64(len(q.tasks)))
	}
	q.cond.Signal()
}

}

func.func @nested_if_op_then_0(%cond: tensor<i1>, %x: tensor<i32>, %y: tensor<i32>) -> (tensor<i32>, tensor<i32>) {
  %0 = "tf.AddV2"(%x, %y) : (tensor<i32>, tensor<i32>) -> tensor<i32>
  func.return %0, %0 : tensor<i32>, tensor<i32>
}

func.func @nested_if_op_else_0(%cond: tensor<i1>, %x: tensor<i32>, %y: tensor<i32>) -> (tensor<i32>, tensor<i32>) {

  return %y: tensor<i1>
}

// CHECK-LABEL: func @while_cond_if
// CHECK: [[cond:%.*]] = tf_mlrt.predicate
// CHECK: [[z:%.*]] = mlrt.cond [[cond]] @then @else
// CHECK: return [[z]]
func.func @while_cond_if(%cond: tensor<i1>, %x: tensor<i1>, %y: tensor<i1>, %z: tensor<i32>) -> (tensor<i1>) {