func PopAppendHTTP(list []*hcm.HttpFilter,
	filterMap map[extensions.PluginPhase][]*model.WasmPluginWrapper,
	phase extensions.PluginPhase,
) []*hcm.HttpFilter {
	for _, ext := range filterMap[phase] {
		list = append(list, toEnvoyHTTPFilter(ext))
	}
	delete(filterMap, phase)
	return list
}

			tgtName := strings.TrimPrefix(k, envVarPrefix)
			if tgtName != "" {
				if v, ok := filterMap[k]; ok {
					if strings.HasPrefix(envVarPrefix, v) {
						filterMap[k] = envVarPrefix
					}
				} else {
					filterMap[k] = envVarPrefix
				}
			}
		}
	}

	for k, v := range filterMap {
		seen.Add(strings.TrimPrefix(k, v))
	}

	seen.Remove(Default)

    }

    // The filter of the convolution may have a `ConvertOp` after the constant
    // op.
    Operation* filter_op = op.getOperand(1).getDefiningOp();
    if (!isa<stablehlo::ConstantOp>(filter_op) &&
        !(isa<stablehlo::ConvertOp>(filter_op) &&
          isa<stablehlo::ConstantOp>(
              filter_op->getOperand(0).getDefiningOp()))) {
      LLVM_DEBUG(llvm::dbgs() << "Failed to match filter_constant_op.\n");

    // Make sure the filter is a constant or a constant transpose.
    Operation* filter_op = filter.getDefiningOp();
    const bool is_constant = isa_and_nonnull<stablehlo::ConstantOp>(filter_op);
    const bool is_constant_transpose =
        isa_and_nonnull<stablehlo::TransposeOp>(filter_op) &&
        isa_and_nonnull<stablehlo::ConstantOp>(
            filter_op->getOperand(0).getDefiningOp());
    if (!is_constant && !is_constant_transpose) {

            params.getExpressedType(), new_bias_scale, 0,
            params.getStorageTypeMin(), params.getStorageTypeMax()));
    arith::ConstantOp filter_op = DuplicateConstantOpIfNeeded(
        op->getOperand(filter_index).getDefiningOp<arith::ConstantOp>(), op,
        filter_index);
    if (!filter_op) {
      return SetOperandParams(op, bias_index, params);
    }

    const auto filter_quantized_type =