// Matches x -> [scast -> scast] -> y, replacing the second scast with the
  // value of x if the casts invert each other.
  auto srcScastOp = getArg().getDefiningOp<StorageCastOp>();
  if (!srcScastOp || srcScastOp.getArg().getType() != getType())
    return OpFoldResult();
  return srcScastOp.getArg();
}

/// The quantization specification should match the expressed type.

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

package org.gradle.api.publish.ivy.internal.dependency;

public interface IvyExcludeRule {
    String getOrg();
    String getModule();
    String getConf();

    b.setInsertionPoint(op);
    if (auto dq = llvm::dyn_cast<quantfork::DequantizeCastOp>(op)) {
      auto dcast = b.create<DequantizeOp>(dq.getLoc(), dq.getResult().getType(),
                                          dq.getArg());
      dq.getResult().replaceAllUsesWith(dcast);
      if (auto extra_attr = op->getAttr(mlir::quant::kVolatileOpAttrName)) {
        dcast->setAttr(mlir::quant::kVolatileOpAttrName, extra_attr);
      }
      dq.erase();

    public DefaultIvyExcludeRule(ExcludeRule excludeRule, String ivyConfiguration) {
        this.excludeRule = excludeRule;
        this.ivyConfiguration = ivyConfiguration;
    }

    @Override
    public String getOrg() {
        return excludeRule.getGroup();
    }

    @Override
    public String getModule() {
        return excludeRule.getModule();
    }

    @Override
    public String getConf() {

    public Request(Object arg, BuildOperationRef buildOperation) {
        Preconditions.checkNotNull(buildOperation);
        this.arg = arg;
        this.buildOperation = buildOperation;
    }

    public Object getArg() {
        return arg;
    }

    public BuildOperationRef getBuildOperation() {
        return buildOperation;
    }

        this.skipIncomingArg = skipIncomingArg;
    }

    @Override
    public void write(Encoder encoder, Request request) throws Exception {
        encoder.encodeChunked(target -> {
            Object object = request.getArg();
            argSerializer.write(target, object);
        });

        encoder.writeLong(request.getBuildOperation().getId().getId());
        OperationIdentifier parentId = request.getBuildOperation().getParentId();

                                                .getStorageType());
        auto new_op = builder.create<TFR::CastOp>(
            returned_op->getLoc(), new_type, returned_op.getArg());
        returned_value.set(new_op.getResult());
        if (returned_op.use_empty()) {
          returned_op.erase();
        }
      } else {
        returned_value.get().getDefiningOp()->emitError(

                                PatternRewriter& rewriter) const override {
    auto preceding_qcast =
        q_op.getArg().getDefiningOp<quantfork::QuantizeCastOp>();
    if (!preceding_qcast) return failure();

    auto new_qcast = rewriter.create<quantfork::QuantizeCastOp>(
        q_op.getLoc(), q_op.getType(), preceding_qcast.getArg());
    new_qcast->setAttr(kVolatileOpAttrName, rewriter.getUnitAttr());
    q_op->replaceAllUsesWith(new_qcast);

                        @Override
                        public Object call() throws Exception {
                            return implementation.run(request.getArg());
                        }
                    });
                } catch (Throwable failure) {
                    if (failure instanceof NoClassDefFoundError) {

              .getOutputDimensions()
              .getDefiningOp<shape::ShapeOfOp>();
      // Check if the shape come from the original conv op.
      if (!shape_of_op ||
          shape_of_op.getArg().getDefiningOp<mhlo::ConvolutionOp>() !=
              conv_op) {
        return failure();
      }
      Value new_shape_of = rewriter.create<shape::ShapeOfOp>(