AvPair p = it.next();
            if ( p.getType() == type ) {
                it.remove();
            }
        }
    }


    /**
     * Replace all occurances of the given type
     * 
     * @param pairs
     * @param rep
     */
    public static void replace ( List<AvPair> pairs, AvPair rep ) {
        remove(pairs, rep.getType());
        pairs.add(rep);
    }

    return false;
  }

  auto opr1_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getOperand(0).getType());
  auto opr2_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getOperand(1).getType());
  auto res_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getResult(0).getType());

  if (!(opr1_type && opr2_type && res_type)) {
    return false;
  }

    if (!preceding_cast) {
      return failure();
    }
    Value input = preceding_cast.getArg();
    Type input_type = input.getType();
    Type output_type = cast_op.getType();

    // Preserve quantization information for intermediate tensors.
    auto intermediate_type = preceding_cast.getType();
    if (isQuantizedType(intermediate_type) || isQuantizedType(output_type)) {
      return failure();
    }

    if (!input_dequant) return failure();

    if (!IsQI32Type(input_dequant.getType())) return failure();

    auto output_type =
        mlir::dyn_cast_or_null<ShapedType>(dequant_op.getOutput().getType());
    if (!output_type || !output_type.getElementType().isF32()) return failure();

    auto input_type = mlir::dyn_cast<ShapedType>(input_dequant.getType());
    // TODO(renjieliu): support UniformQuantizedPerAxisType.

      auto dcast = b.create<quantfork::DequantizeCastOp>(
          dq.getLoc(), dq.getOutput().getType(), dq.getInput());
      dq.getOutput().replaceAllUsesWith(dcast);
      dq.erase();
    } else if (auto q = llvm::dyn_cast<QuantizeOp>(op)) {
      auto qcast = b.create<quantfork::QuantizeCastOp>(
          q.getLoc(), q.getOutput().getType(), q.getInput());
      q.getOutput().replaceAllUsesWith(qcast);
      q.erase();

            SmbResourceLocator fl = p.getLocator();
            assertNull(fl.getServer());
            assertNull(fl.getShare());
            assertEquals(SmbConstants.TYPE_WORKGROUP, fl.getType());
            assertEquals("\\", fl.getUNCPath());
            assertEquals("smb://", fl.getCanonicalURL());
            assertEquals("/", fl.getURLPath());
        }
    }


    @Test

        ProviderInternal<T> provider,
        Spec<? super T> spec
    ) {
        this.spec = spec;
        this.provider = provider;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return provider.getType();
    }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return provider.getProducer();
        }
    }

    private static final String BOXED_BYTE_TYPE = getType(Byte.class).getInternalName();
    private static final String BOXED_SHORT_TYPE = getType(Short.class).getInternalName();
    private static final String BOXED_INT_TYPE = getType(Integer.class).getInternalName();
    private static final String BOXED_LONG_TYPE = getType(Long.class).getInternalName();

// matches the expected type otherwise an error should be thrown, but for now
// we're just returning empty vector
template <>
inline std::vector<bool> GetVector(DenseElementsAttr elements) {
  auto type = elements.getType();
  auto elemType = type.getElementType();
  if (elemType.isSignlessInteger(1)) {
    auto vec = llvm::to_vector(
        llvm::map_range(elements.getValues<bool>(),

    ImmutableList<Parameter> parameters = delegate.getParameters();
    assertEquals(2, parameters.size());
    assertEquals(String.class, parameters.get(0).getType().getType());
    assertTrue(parameters.get(0).isAnnotationPresent(NotBlank.class));
    assertEquals(int.class, parameters.get(1).getType().getType());
    assertFalse(parameters.get(1).isAnnotationPresent(NotBlank.class));
    new EqualsTester()
        .addEqualityGroup(parameters.get(0))