YES
* Step 1: FromIts YES
    + Considered Problem:
        Rules:
          0. f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(A,1 + B,D,O,D,P,B,H,I,J,K,L,M,N) [A >= 1 + B && B >= 0]                 (?,1)
          1. f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,O,S,V,W,C,M,N)     [B >= A && B >= 0 && Q >= O && O >= 2] (?,1)
          2. f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(R,S,Q,V,U,F,G,P,T,W,Y,0,O,N)     [0 >= P && 0 >= X]                     (1,1)
          3. f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(P,2,R,Q,R,F,G,P,R,J,K,L,O,S)     [P >= 2]                               (1,1)
          4. f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,1,S,V,W,D,O,N)     True                                   (1,1)
        Signature:
          {(f1,14);(f3,14);(f4,14)}
        Flow Graph:
          [0->{0,1},1->{},2->{},3->{0,1},4->{}]
        
    + Applied Processor:
        FromIts
    + Details:
        ()
* Step 2: Decompose YES
    + Considered Problem:
        Rules:
          f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(A,1 + B,D,O,D,P,B,H,I,J,K,L,M,N)   [A >= 1 + B && B >= 0]
          f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,O,S,V,W,C,M,N)       [B >= A
                                                                                    && B >= 0
                                                                                    && Q >= O
                                                                                    && O >= 2]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(R,S,Q,V,U,F,G,P,T,W,Y,0,O,N)       [0 >= P && 0 >= X]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(P,2,R,Q,R,F,G,P,R,J,K,L,O,S)       [P >= 2]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,1,S,V,W,D,O,N)       True
        Signature:
          {(f1,14);(f3,14);(f4,14)}
        Rule Graph:
          [0->{0,1},1->{},2->{},3->{0,1},4->{}]
    + Applied Processor:
        Decompose NoGreedy
    + Details:
        We construct a looptree:
          P: [0,1,2,3,4]
          |
          `- p:[0] c: [0]
* Step 3: CloseWith YES
    + Considered Problem:
        (Rules:
          f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(A,1 + B,D,O,D,P,B,H,I,J,K,L,M,N)   [A >= 1 + B && B >= 0]
          f1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,O,S,V,W,C,M,N)       [B >= A
                                                                                    && B >= 0
                                                                                    && Q >= O
                                                                                    && O >= 2]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(R,S,Q,V,U,F,G,P,T,W,Y,0,O,N)       [0 >= P && 0 >= X]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f1(P,2,R,Q,R,F,G,P,R,J,K,L,O,S)       [P >= 2]
          f3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) -> f4(P,Q,R,U,T,F,G,1,S,V,W,D,O,N)       True
        Signature:
          {(f1,14);(f3,14);(f4,14)}
        Rule Graph:
          [0->{0,1},1->{},2->{},3->{0,1},4->{}]
        ,We construct a looptree:
          P: [0,1,2,3,4]
          |
          `- p:[0] c: [0])
    + Applied Processor:
        CloseWith True
    + Details:
        ()

YES