class MatchPredicate implements Symbol {

    private final Map<Symbol, Symbol> identBoostMap;
    private final Symbol queryTerm;
    private final String matchType;
    private final Symbol options;

    public MatchPredicate(Map<Symbol, Symbol> identBoostMap,
                          Symbol queryTerm,
                          String matchType,
                          Symbol options) {
        assert options.valueType().id() == ObjectType.ID : "options symbol must be of type object";
        this.identBoostMap = identBoostMap;
        this.queryTerm = queryTerm;
        this.matchType = matchType;
        this.options = options;
    }

    public Map<Symbol, Symbol> identBoostMap() {
        return identBoostMap;
    }

    public Symbol queryTerm() {
        return queryTerm;
    }

    public String matchType() {
        return matchType;
    }

    public Symbol options() {
        return options;
    }

    @Override
    public SymbolType symbolType() {
        return SymbolType.MATCH_PREDICATE;
    }

    @Override
    public <C, R> R accept(SymbolVisitor<C, R> visitor, C context) {
        return visitor.visitMatchPredicate(this, context);
    }

    @Override
    public BooleanType valueType() {
        return DataTypes.BOOLEAN;
    }

    @Override
    public void writeTo(StreamOutput out) throws IOException {
        throw new UnsupportedOperationException("Cannot stream MatchPredicate");
    }

    @Override
    public String toString() {
        return toString(Style.UNQUALIFIED);
    }

    @Override
    public long ramBytesUsed() {<FILL_FUNCTION_BODY>}

    @Override
    public String toString(Style style) {
        StringBuilder sb = new StringBuilder("MATCH((");
        Iterator<Map.Entry<Symbol, Symbol>> it = identBoostMap.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<Symbol, Symbol> entry = it.next();
            sb.append(entry.getKey().toString(style));
            sb.append(" ");
            sb.append(entry.getValue().toString(style));
            if (it.hasNext()) {
                sb.append(", ");
            }
        }
        sb.append("), ");
        sb.append(queryTerm.toString(style));
        sb.append(") USING ");
        sb.append(matchType);
        sb.append(" WITH (");
        sb.append(options.toString(style));
        sb.append(")");
        return sb.toString();
    }
}

        long bytes = 0L;
        for (var entry : identBoostMap.entrySet()) {
            bytes += entry.getKey().ramBytesUsed();
            bytes += entry.getValue().ramBytesUsed();
        }
        return bytes
            + queryTerm.ramBytesUsed()
            + RamUsageEstimator.sizeOf(matchType)
            + options.ramBytesUsed();
    
<no_super_class>