var l _List[int]
	l.PushBack(1)
	l.PushBack(2)
	l.PushBack(3)
	l.InsertBefore(1, new(_Element[int]))
	checkList(&l, []interface{}{1, 2, 3})
}

// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
func TestInsertAfterUnknownMark() {
	var l _List[int]
	l.PushBack(1)
	l.PushBack(2)
	l.PushBack(3)
	l.InsertAfter(1, new(_Element[int]))

                                   std::vector<Output>* grad_outputs) {
  grad_outputs->push_back(Identity(scope, grad_inputs[0]));
  grad_outputs->push_back(NoGradient());
  grad_outputs->push_back(NoGradient());
  grad_outputs->push_back(NoGradient());
  return scope.status();
}
REGISTER_GRADIENT_OP("QuantizeAndDequantizeV3", QuantizeAndDequantizeV3Grad);

                epsilon, data_format, is_training));
        grad_outputs->push_back(grad.x_backprop);
        grad_outputs->push_back(grad.scale_backprop);
        grad_outputs->push_back(grad.offset_backprop);
        grad_outputs->push_back(NoGradient());
        grad_outputs->push_back(NoGradient());
        return scope.status();
      },
      grad_outputs);
}

          for (size_t i = 0; i < vector.size(); i++) {
            vec.push_back(vector[i].AsInt64());
          }
          std::vector<int64_t> shape;
          if (std::string{key} == "padding") {
            shape.push_back(vec.size() / 2);
            shape.push_back(2);
          } else {
            shape.push_back(vec.size());
          }
          Attribute value;

  SmallVector<Type, 4> while_input_types;
  while_input_values.push_back(const_true.getResult());
  while_input_types.push_back(const_true.getResult().getType());
  for (int i = 1; i < reduce_dataset.getNumOperands(); ++i) {
    while_input_values.push_back(reduce_dataset.getOperand(i));
    while_input_types.push_back(reduce_dataset.getOperand(i).getType());
  }

    }
  }
  attrs.push_back(rewriter.getNamedAttr("lhs_quantization_axis",
                                        activation_quantization_axis));
  attrs.push_back(rewriter.getNamedAttr("rhs_quantization_axis",
                                        activation_quantization_axis));
  attrs.push_back(rewriter.getNamedAttr("output_quantization_axis",

    // Treats empty input shape as scalar
    if (dim_str.empty()) continue;
    if (dim_str == "?") {
      dims.push_back(-1);
      continue;
    }
    int size;
    TF_RET_CHECK(absl::SimpleAtoi(dim_str, &size));
    dims.push_back(size);
  }
  return dims;
}

static Status HandleSubtype(absl::string_view subtype,
                            ArrayInfo::SubTypeInfo* result) {

    for (auto it = begin_if_op_iter; it != std::next(current_last_if_op_iter);
         ++it) {
      sub_if_group.push_back(*it);
    }
    it_merged.first->getSecond().push_back(sub_if_group);
    it_moved.first->getSecond().push_back(
        GetMoveOpList(sub_if_group, side_effect_analysis));
    begin_if_op_iter = std::next(current_last_if_op_iter);
  }
}

  if (matchPattern(permutation1, m_Constant(&perm1_const))) {
    for (int32_t idx = 0; idx < perm1_const.getNumElements(); ++idx) {
      initial_permutation.push_back(idx);
    }
    for (auto perm : perm2_const.getValues<APInt>()) {
      new_permutation.push_back(
          initial_permutation[perm1_const
                                  .getValues<APInt>()[perm.getSExtValue()]
                                  .getSExtValue()]);

    (*arguments_to_erase)[call].push_back(argument_index);
    if (auto func = dyn_cast<func::FuncOp>(call.resolveCallable())) {
      (*arguments_to_erase)[func].push_back(argument_index);
      work_list->push_back(std::make_pair(&func.getRegion(), argument_index));
    }
  } else if (auto if_op = dyn_cast<TF::IfOp>(user_op)) {
    (*arguments_to_erase)[if_op].push_back(argument_index);