MAYBE
We consider the system theBenchmark.

  Alphabet:

    0 : [] --> b 
    cons : [b * b] --> b 
    del : [b * b] --> b 
    eq : [b * b] --> a 
    false : [] --> a 
    filter : [b -> a * b] --> b 
    filter2 : [a * b -> a * b * b] --> b 
    if : [a * b * b] --> b 
    le : [b * b] --> a 
    map : [b -> b * b] --> b 
    min : [b * b] --> b 
    minsort : [b] --> b 
    nil : [] --> b 
    s : [b] --> b 
    true : [] --> a 

  Rules:

    le(0, x) => true 
    le(s(x), 0) => false 
    le(s(x), s(y)) => le(x, y) 
    eq(0, 0) => true 
    eq(0, s(x)) => false 
    eq(s(x), 0) => false 
    eq(s(x), s(y)) => eq(x, y) 
    if(true, x, y) => x 
    if(false, x, y) => y 
    minsort(nil) => nil 
    minsort(cons(x, y)) => cons(min(x, y), minsort(del(min(x, y), cons(x, y)))) 
    min(x, nil) => x 
    min(x, cons(y, z)) => if(le(x, y), min(x, z), min(y, z)) 
    del(x, nil) => nil 
    del(x, cons(y, z)) => if(eq(x, y), z, cons(y, del(x, z))) 
    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).