setSupplier(noValueSupplier());
        } else if (value.hasFixedValue()) {
            setSupplier(new FixedSupplier<>(value.getFixedValue(), Cast.uncheckedCast(value.getSideEffect())));
        } else {
            CollectingProvider<T, C> asCollectingProvider = Cast.uncheckedNonnullCast(value.getChangingValue());
            setSupplier(new CollectingSupplier(new ElementsFromCollectionProvider<>(asCollectingProvider)));
        }

  auto input_args_have_static_shape = [&]() -> bool {
    return mlir::cast<TensorType>(input_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(kernel_tensor.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(window_strides.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(padding.getType()).hasStaticShape() &&
           mlir::cast<TensorType>(lhs_dilation.getType()).hasStaticShape() &&

        if (OperationCompletionListener.class.isAssignableFrom(providerInternal.getType())) {
            onTaskCompletion(Cast.uncheckedCast(provider));
        } else {
            onOperationCompletion(Cast.uncheckedCast(provider));
        }
    }

    @Override
    public void onOperationCompletion(Provider<? extends BuildOperationListener> listenerProvider) {

            return Cast.uncheckedCast(implementationFactory);
        }

        Class<?> superclass = implementationClass.getSuperclass();
        if (superclass != null && superclass != Object.class) {
            implementationFactory = findFactory(superclass);
            factories.put(implementationClass, implementationFactory);
            return Cast.uncheckedCast(implementationFactory);
        }

 */

package org.gradle.internal.nativeintegration.services

import net.rubygrapefruit.platform.Native
import org.gradle.api.internal.file.temp.TemporaryFileProvider
import org.gradle.internal.Cast
import org.gradle.internal.concurrent.Stoppable
import org.gradle.internal.file.Chmod
import org.gradle.internal.reflect.JavaMethod
import org.gradle.internal.service.ServiceRegistration

 * limitations under the License.
 */

package org.gradle.tooling.internal.provider.serialization;

import javax.annotation.concurrent.ThreadSafe;

import org.gradle.internal.Cast;
import org.gradle.internal.IoActions;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.io.StreamByteBuffer;

import javax.annotation.Nullable;
import java.io.IOException;

import java.util.function.Function;
import java.util.function.Supplier;

import static org.gradle.api.services.internal.BuildServiceProvider.asBuildServiceProvider;
import static org.gradle.internal.Cast.uncheckedCast;
import static org.gradle.internal.Cast.uncheckedNonnullCast;

public class DefaultBuildServicesRegistry implements BuildServiceRegistryInternal, HoldsProjectState {

    private final BuildIdentifier buildIdentifier;

          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() <= 1">,
          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() == 2 && !$_op.getOperand(0).getType().cast<ShapedType>().hasStaticShape()">,
          CPred<"$_op.getOperand(0).getType().cast<ShapedType>().getRank() == 2 && $_op.getOperand(0).getType().cast<ShapedType>().getShape()[1] <= 4">]>>]> {

/**
 * A receiver value of a call.
 */
public sealed class KaReceiverValue : KaLifetimeOwner {
    /**
     * Returns inferred [KaType] of the receiver.
     *
     * In case of smart cast on the receiver returns smart cast type.
     *
     * For builder inference in FIR implementation it currently works incorrectly, see KT-50916.
     */
    public abstract val type: KaType
}


/**

  auto composite_result_shape =
      mlir::cast<ShapedType>(old_op->getResults().front().getType()).getShape();
  std::array<int64_t, 4> output_shape;
  // NHWC <- NCHW
  output_shape[0] = composite_result_shape[0];
  output_shape[1] = composite_result_shape[2];
  output_shape[2] = composite_result_shape[3];
  output_shape[3] = composite_result_shape[1];

  auto input_type = mlir::cast<ShapedType>(old_op->getOperand(0).getType());