MAYBE
We consider the system theBenchmark.

  Alphabet:

    0 : [] --> a 
    cons : [c * d] --> d 
    false : [] --> b 
    filter : [c -> b * d] --> d 
    filter2 : [b * c -> b * c * d] --> d 
    map : [c -> c * d] --> d 
    minus : [a * a] --> a 
    nil : [] --> d 
    plus : [a * a] --> a 
    quot : [a * a] --> a 
    s : [a] --> a 
    true : [] --> b 

  Rules:

    minus(x, 0) => x 
    minus(s(x), s(y)) => minus(x, y) 
    quot(0, s(x)) => 0 
    quot(s(x), s(y)) => s(quot(minus(x, y), s(y))) 
    plus(0, x) => x 
    plus(s(x), y) => s(plus(x, y)) 
    plus(minus(x, s(0)), minus(y, s(s(z)))) => plus(minus(y, s(s(z))), minus(x, s(0))) 
    plus(plus(x, s(0)), plus(y, s(s(z)))) => plus(plus(y, s(s(z))), plus(x, s(0))) 
    map(f, nil) => nil 
    map(f, cons(x, y)) => cons(f x, map(f, y)) 
    filter(f, nil) => nil 
    filter(f, cons(x, y)) => filter2(f x, f, x, y) 
    filter2(true, f, x, y) => cons(x, filter(f, y)) 
    filter2(false, f, x, y) => filter(f, y) 

This AFS is converted to an AFSM simply by replacing all free variables by meta-variables (with arity 0).