type = op->getResult(0).getType().cast<ShapedType>();
  } else if (llvm::isa<TF::AssignVariableOp>(op)) {
    type = op->getOperand(1).getType().cast<ShapedType>();
  } else if (llvm::isa<TF::VarHandleOp>(op)) {
    type = op->getResult(0)
               .getType()
               .cast<ShapedType>()
               .getElementType()
               .cast<TF::TensorFlowTypeWithSubtype>()
               .GetSubtypes()

        setDidWork(result.getDidWork());
    }

    private Compiler<SymbolExtractorSpec> createCompiler() {
        NativePlatformInternal targetPlatform = Cast.cast(NativePlatformInternal.class, this.targetPlatform.get());
        NativeToolChainInternal toolChain = Cast.cast(NativeToolChainInternal.class, getToolChain().get());
        PlatformToolProvider toolProvider = toolChain.select(targetPlatform);

    return cast(type, put(type, value));
  }

  @Override
  @CheckForNull
  public <T extends @NonNull B> T getInstance(Class<T> type) {
    return cast(type, get(type));
  }

  @CanIgnoreReturnValue
  @CheckForNull
  private static <T> T cast(Class<T> type, @CheckForNull Object value) {
    return Primitives.wrap(type).cast(value);
  }

  private Object writeReplace() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.specs;

import org.gradle.internal.Cast;

public class ExplainingSpecs {

    private static final ExplainingSpec<Object> SATISFIES_ALL = new ExplainingSpec<Object>() {
        @Override
        public boolean isSatisfiedBy(Object element) {

                           .cast<TensorType>()
                           .getElementType()
                           .cast<ResourceType>();
  if (resource_type.getSubtypes().size() == 1)
    return resource_type.getSubtypes().front();

  return UnrankedTensorType::get(element_type);
}

static bool HasResourceSubtype(Value resource) {
  return resource.getType()
             .cast<TensorType>()
             .getElementType()

	x *= x           // try to trash high bits (arch-dependent)
	*p = x           // store
	return int32(*p) // load and cast
}

//go:noinline
func loadHitStoreU8(x uint8, p *uint8) uint32 {
	x *= x            // try to trash high bits (arch-dependent)
	*p = x            // store
	return uint32(*p) // load and cast
}

//go:noinline
func loadHitStore16(x int16, p *int16) int32 {

    %cst = "tf.Const"() {value = dense<1024> : tensor<i32>} : () -> tensor<i32>
    %0:2 = "tf_device.launch"() ({
	  %1 = "tf.Cast"(%arg0) {Truncate = false} : (tensor<2048xi64>) -> tensor<2048xi32>
	  %2 = "tf.Cast"(%arg1) {Truncate = false} : (tensor<2048xi64>) -> tensor<2048xi32>

        this.implementationInfo = implementationInfo;
    }

    @Override
    protected void initializePrivateData(MutableModelNode modelNode) {
        ModelType<T> delegateType = Cast.uncheckedCast(implementationInfo.getDelegateType());
        T instance = Cast.uncheckedCast(implementationInfo.create(modelNode));
        modelNode.setPrivateData(delegateType, instance);
    }

 */

package org.gradle.model.internal.core;

import org.gradle.internal.Cast;
import org.gradle.model.internal.type.ModelType;

public class ChildNodeInitializerStrategyAccessors {

    private static final ModelType<ChildNodeInitializerStrategy<?>> CHILD_NODE_INITIALIZER_STRATEGY_MODEL_TYPE =
        Cast.uncheckedCast(ModelType.of(ChildNodeInitializerStrategy.class));

        configureAction.execute(versionConstraint);
        return Cast.uncheckedCast(this);
    }

    @Override
    public T attributes(Action<? super AttributeContainer> configureAction) {
        configureAction.execute(attributes);
        return Cast.uncheckedCast(this);
    }

    @Override
    public String getReason() {
        return reason;
    }