def operation = parsed.operation.name
        def operands = parsed.operation.operands.collect { e ->
            "${toExclude(e)}"
        }
        """
${operands.indexed().collect { i, e -> "def operand$i = $e" }.join("\n")}
def operation = factory.$operation([
   ${operands.indexed().collect { i, e -> "operand$i" }.join(",\n   ")}
] as Set)
"""
    }

    private String toExclude(it) {

      return fetch.emitOpError()
             << "operand #" << i << " does not have a graph results to bind";
    if (graph.getResult(i).getType() != operand.getType()) {
      return fetch.emitOpError()
             << "operand #" << i << " type mismatch graph results ("
             << graph.getResult(i).getType() << " != " << operand.getType()
             << ")";
    }
  }
  return success();
}

}

// It reduces the following pattern:
//
// S = (0, 0, 0)
// while S[2] < 3:
//  a0 = S[0] * 2
//  a1 = a0 + S[1]
//  a2 = S[2] + 1
//  S = (a0, a1, a2)
// return S[0]
//
// the 2nd operand (i = 1) as well as its related op (a1 = a0 + S[1])
// can be removed since only S[0] is returned.
// It cannot be removed by loop-invariant-code-motion pass since every value
// is used and changed in the while loop.

            operand18,
            operand19,
            operand20,
            operand21,
            operand22,
            operand23,
            operand24,
            operand25,
            operand26,
            operand27,
            operand28,
            operand29,
            operand30,
            operand31,
            operand32,
            operand33,
            operand34,

  // input operand.
  if (used_args.count() != num_args) {
    // Traverse arguments backward so that indices to be deleted stay unchanged.
    for (int idx = num_args - 1; idx >= 0; --idx) {
      if (used_args.test(idx)) continue;
      for (func::FuncOp func : cloned_branches) func.eraseArgument(idx);
      // For if/case, arg #i of attached function corresponds to operand #i+1
      op->eraseOperand(idx + 1);

}

// Returns the gradient wrt an input operand for a binary einsum.
//
// This function does not handle (un)broadcasting. This must be done separately
// on the returned gradient.
//
// Args:
//   output_grad: The gradient wrt the output of a binary einsum operation.
//   other_operand: The complementary `Tensor` operand i.e. which is not the
//     input operand.

	cgofunc:   "cgo function",
}

// An operand represents an intermediate value during type checking.
// Operands have an (addressing) mode, the expression evaluating to
// the operand, the operand's type, a value for constants, and an id
// for built-in functions.
// The zero value of operand is a ready to use invalid operand.
type operand struct {
	mode operandMode
	expr ast.Expr
	typ  Type
	val  constant.Value
	id   builtinId
}

	cgofunc:   "cgo function",
}

// An operand represents an intermediate value during type checking.
// Operands have an (addressing) mode, the expression evaluating to
// the operand, the operand's type, a value for constants, and an id
// for built-in functions.
// The zero value of operand is a ready to use invalid operand.
type operand struct {
	mode operandMode
	expr syntax.Expr
	typ  Type

  BidirectionalSequenceLSTMOp op = *this;
  auto operands = op.GetStatefulOperands();
  if (operands.size() == 4 && operands[0] == 35 && operands[1] == 36 &&
      operands[2] == 37 && operands[3] == 38) {
    return success();
  }
  return op.emitError(
      "BidirectionalSequenceLSTMOp expected to have four stateful operands");
}

    Interface for ops potentially have same operands and results scales.
  }];

  let methods = [
    InterfaceMethod<
      [{Returns whether same operands and results scales are required.}],
      "bool", "RequiredSameOperandsAndResultsScale",
      (ins "bool":$sign, "int":$bit_width), [{}], [{return true;}]
    >,
    InterfaceMethod<
      [{Returns whether operands and results must have the same quantized axis.}],