&read_value_handle));
  Status status;
  AbstractTensorPtr read_value(read_value_handle->Resolve(&status));
  TF_EXPECT_OK(status);
  EXPECT_FLOAT_EQ(42.0, *static_cast<float*>(read_value->Data()));
}

}  // namespace

  x = variables.Variable(1.0, name='x')
  y = variables.Variable(1.0, name='y')
  updates = control_flow_ops.no_op()
  for _ in range(3):
    with ops.control_dependencies([updates]):
      x_val = x.read_value() + y
      updates = x.assign_sub(0.1 * x_val)

  array_ops.identity(updates, name='result')


def write_graph(build_graph, out_dir):
  """Build a graph using build_graph and write it out."""

  }
}

ElementsAttr QuantizeLegacy(const Attribute real_value,
                            const Type tensor_type) {
  if (!isa<DenseFPElementsAttr>(real_value) ||
      !quant::QuantizedType::getQuantizedElementType(tensor_type)) {
    return {};
  }
  const auto real_values_attr = cast<DenseFPElementsAttr>(real_value);
  auto q_type = quant::QuantizedType::getQuantizedElementType(tensor_type);

/// converted type in outConvertedType.
///
/// Examples:
/// 1. realValue is a primitive value attribute:
/// (realValue: FloatAttr, quantizedElementType: UniformQuantizedType[i8:f32])
///   -> (IntegerAttr, outConvertedType: i8)
/// 2. realValue is an elements attribute:
/// (realValue: DenseElementsAttr[tensor<2x2xf32>],
///  quantizedElementType: UniformQuantizedType[i8:f32])

                                   quantizedElementType, converter);
    outConvertedType = converted.getType();
    return converted;
  }
  if (mlir::isa<SparseElementsAttr>(realValue)) {
    // Sparse tensor or vector constant.
    auto converted =
        convertSparseElementsAttr(mlir::cast<SparseElementsAttr>(realValue),
                                  quantizedElementType, converter);

DenseElementsAttr GetScalarOfType(Type ty, T raw_value) {
  RankedTensorType scalar_ty = RankedTensorType::get({}, ty);
  if (auto float_ty = mlir::dyn_cast<FloatType>(ty)) {
    FloatAttr attr = FloatAttr::get(float_ty, raw_value);
    return DenseElementsAttr::get(scalar_ty, attr);
  } else if (auto int_ty = mlir::dyn_cast<IntegerType>(ty)) {
    IntegerAttr attr = IntegerAttr::get(int_ty, raw_value);
    return DenseElementsAttr::get(scalar_ty, attr);

    /**
     * Create or load value, with load-after-store semantics
     */
    fun loadOrCreateValue(key: K, creator: () -> V): V {
        val address = loadOrCreateAddress(key, creator)
        return readValue(key, address)
    }

    /**
     * If value has to be created, the original value is returned without (de)serialization
     *

package org.gradle.kotlin.dsl.provider

import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue

import com.nhaarman.mockito_kotlin.doReturn
import com.nhaarman.mockito_kotlin.mock

import org.gradle.api.internal.initialization.AbstractClassLoaderScope

import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath

        File oldFile = new File(args[0])
        File newFile = new File(args[1])
        PerformanceTestScenarioDefinition oldJson = new ObjectMapper().readValue(oldFile, PerformanceTestScenarioDefinition).sort()
        PerformanceTestScenarioDefinition newJson = new ObjectMapper().readValue(newFile, PerformanceTestScenarioDefinition).sort()
        if (oldJson != newJson) {

	"./a"
)

var G int

// An inlinable function. To trigger the bug in question this needs
// to be inlined here within the package and also inlined into some
// other package that imports it.
func ReadValues(data []byte) (vals map[string]interface{}, err error) {
	err = a.Unmarshal(data, &vals)
	if len(vals) == 0 {
		vals = map[string]interface{}{}
	}
	return
}