split_dimension_op.getOutput(),
                                                 reshape_op.getOutput());

    // Squeeze each batch, i.e. reshape
    // [1, num_rows, num_cols] -> [num_rows, num_cols]
    for (const auto& split_value : split_op.getOutput()) {
      auto reshape_op = createReshapeOp(split_value, {num_rows, num_cols},

    return rewriter.create<TF::ConstOp>(loc, static_shape_attr).getOutput();
  }

  // If the shape is not static, create a new ShapeOp.
  BoolAttr false_attr = rewriter.getBoolAttr(false);
  return rewriter
      .create<TF::ShapeOp>(loc, input,
                           /*use_32bit=*/false_attr)
      .getOutput();
}

mlir::TFL::MirrorPaddingType GetTFLMirrorPaddingFromString(

            new DslObject(resourcesTask.getRootSpec()).getConventionMapping().map("destinationDir", (Callable<File>) () -> sourceSet.getOutput().getResourcesDir());
            resourcesTask.from(resourceSet);
        });
        DefaultSourceSetOutput output = Cast.uncheckedCast(sourceSet.getOutput());
        output.setResourcesContributor(processResources.map(Copy::getDestinationDir), processResources);
    }

    squeeze_op.getResult().setType(bts_op.getOutput().getType());

    // Connect `biasadd_op` with the output of `squeeze_op`.
    if (biasadd_op) {
      biasadd_op.setOperand(0, squeeze_op.getOutput());
      biasadd_op.getOutput().setType(squeeze_op.getOutput().getType());
    }
  } else {
    if (biasadd_op) biasadd_op.setOperand(0, op.getOutput());
    op.setOperand(0, stb_op.getInput());

        tensor_proto_attr.getValue(),
        mlir::dyn_cast<TensorType>(ToLegalType(op.getOutput().getType())));
    if (failed(dense_attr_or)) {
      op->emitError("failed to get DenseElementAttr.");
      return failure();
    }

    rewriter.replaceOpWithNewOp<TF::ConstOp>(
        op, ToLegalType(op.getOutput().getType()), *dense_attr_or);
    return success();
  }
};

struct ConvertTFQuantTypes

  LogicalResult matchAndRewrite(TF::UniformQuantizeOp op,
                                PatternRewriter &rewriter) const override {
    auto output_type = GetUniformQuantizedType(
        op, op.getOutput().getType(), op.getScales(), op.getZeroPoints(),
        /*expressed_type=*/rewriter.getF32Type(), op.getQuantizationMinVal(),
        op.getQuantizationMaxVal(), op.getQuantizationAxis(), rewriter);

                .build()
        }
        1 * implicitInput1.getInput() >> '/foo/bar'
        1 * implicitInput1.getOutput() >> 'abcdef012'
        1 * implicitInput2.getInput() >> '/foo/baz'
        1 * implicitInput2.getOutput() >> 'abcdef987'
        1 * validator.isValid(cachePolicy, _) >> true
        1 * service.isUpToDate('/foo/bar', 'abcdef012') >> true

  auto reshape = builder.create<TF::ReshapeOp>(
      loc, ArrayRef<Type>{element_type},
      ArrayRef<Value>{slice,
                      GetR1Const(element_type.getShape(), builder, loc)});
  return reshape.getOutput();
}

Value SetElement(Value index, Value buffer, Value element, OpBuilder builder,
                 Location loc) {
  auto buffer_type = mlir::cast<RankedTensorType>(buffer.getType());

                                 preceding_cast.getOut().getType()) {
        return failure();
      }
      raw_data_op.getOutput().replaceAllUsesWith(redundant_cast.getArg());
    } else {
      // If the argument of cast op is input, then simply remove the RawData op.
      raw_data_op.getOutput().replaceAllUsesWith(preceding_cast.getOut());
    }
    return success();
  }

        host_tensor, device_, device_tensor));

    tensors_.push_back(device_tensor);
    return device_tensor;
  }

  // Gets the `output_index`-th output set in the context_
  Tensor* GetOutput(int output_index) {
    CHECK_LT(output_index, context_->num_outputs());
    Tensor* device_tensor = context_->mutable_output(output_index);
    managed_outputs_.resize(context_->num_outputs());