/export/starexec/sandbox/solver/bin/starexec_run_complexity /export/starexec/sandbox/benchmark/theBenchmark.koat /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), ?) proof of /export/starexec/sandbox/benchmark/theBenchmark.koat # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty The runtime complexity of the given CpxIntTrs could be proven to be BOUNDS(n^1, INF). (0) CpxIntTrs (1) Loat Proof [FINISHED, 1296 ms] (2) BOUNDS(n^1, INF) ---------------------------------------- (0) Obligation: Complexity Int TRS consisting of the following rules: f12(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f116(A, B, 1, -(1), F, F, Z1, 1 + F, A2, Z1, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: A >= 2 && Y1 >= A && B >= 0 && C >= 1 && C <= 1 f13(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f116(A, B, 2, D, Z1, -(1) + Z1, G, H, I, A2, 2, -(1), Y1, B2, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: E >= 0 && A >= 2 f116(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f300(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, 1, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: F >= O && P >= 1 && P <= 1 f1(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f1(A, 1 + B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, S, Z1, S, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: B >= 0 && Q >= B + 1 f1(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f116(A, Z1, 0, D, E, F, G, H, I, J, K, L, M, N, O, P, A2, Y1, D2, B2, R, R, E2, F2, G2, Z1, C2, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: A >= 2 && C2 >= A && F >= A && B >= Q && B >= 0 && C >= 0 && C <= 0 f7(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, Z1, D1, D1, -(1) + Z1, -(1), G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: B1 >= 0 f7(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f10(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, E2, Z, A1, B1, F2, D2, E1, F1, B2, Z1, A2, Y1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: B1 >= 0 && G1 >= D1 && G1 <= D1 f8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, 0, H1, W, X, Y, Z, A1, B1, D1, D1, -(1) + E1, F1, 0, H1, 0, H1, -(1) + E1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: E1 >= 0 && A >= 2 && I1 >= 0 && I1 <= 0 && H1 >= V && H1 <= V && G1 >= 0 && G1 <= 0 && U >= 0 && U <= 0 && J1 >= V && J1 <= V f8(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f10(E2, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, F2, Z, A1, B1, G2, D2, E1, F1, B2, Z1, A2, Y1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: E1 >= 0 && G1 >= D1 && G1 <= D1 f13(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f8(A, B, E1 + 1, D, 0, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, 0, V, W, X, Y, Z, A1, E1, V, V, E1, F1, 0, V, 0, V, K1, -(1), M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: A >= 2 && U >= 0 && U <= 0 && E >= 0 && E <= 0 && C >= 1 && C <= 1 f116(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f116(A, B, 1 + C, D, E, -(1) + F, G, H, I, J, K, L, M, N, F, 1, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, U, 1 + C, -(1) + F, P1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: A >= 2 && C >= 0 && F >= 0 && P >= 0 && P <= 0 && U >= M1 && U <= M1 f116(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f8(A, B, E1 + 1, D, E, F, G, H, I, J, K, L, M, N, F, 1, Q, R, S, T, 0, V, W, X, Y, Z, A1, E1, V, V, E1, F1, 0, V, 0, V, K1, -(1), M1, N1, O1, Z1, Q1, R1, S1, T1, U1, V1, W1, X1)) :|: Z1 >= 0 && A >= 2 && C >= 0 && F >= 0 && U >= 0 && U <= 0 && P >= 0 && P <= 0 f9(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f1(Z1, 2, C, D, E, F, G, H, I, J, K, L, M, N, O, 0, Z1, S, B2, S, U, V, S, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, A2, Y1, D2, 2, E2, V1, W1, X1)) :|: Z1 >= 2 && S >= W && S <= W f9(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f10(F2, E2, C, D, E, F, G, H, I, J, K, L, M, N, O, 0, C2, H2, J2, I2, 0, 0, K2, L2, M2, Z, A1, B1, N2, D2, E1, F1, B2, Z1, A2, Y1, K1, L1, M1, N1, O1, P1, Q1, G2, S1, T1, U1, V1, W1, X1)) :|: 0 >= F2 f9(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1) -> Com_1(f10(1, E2, C, D, E, F, G, H, I, J, K, L, M, N, O, 0, H2, I2, K2, J2, 0, 0, M2, N2, O2, Z, A1, B1, Q2, D2, E1, F1, B2, Z1, A2, Y1, K1, L1, M1, N1, O1, P1, G2, C2, L2, T1, U1, F2, G2, P2)) :|: S >= 0 && S <= 0 && W >= 0 && W <= 0 The start-symbols are:[f9_50] ---------------------------------------- (1) Loat Proof (FINISHED) ### Pre-processing the ITS problem ### Initial linear ITS problem Start location: f9 0: f12 -> f116 : C'=1, D'=-1, E'=F, G'=free_1, H'=1+F, Q'=free, J'=free_1, [ A>=2 && free_2>=A && B>=0 && C==1 ], cost: 1 1: f13 -> f116 : C'=2, E'=free_5, F'=-1+free_5, J'=free_4, K'=2, L'=-1, M'=free_6, N'=free_3, [ E>=0 && A>=2 ], cost: 1 9: f13 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, E'=0, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, U'=0, [ A>=2 && U==0 && E==0 && C==1 ], cost: 1 2: f116 -> f300 : A1'=B, A2'=C, B'=D, B1'=E, B2'=F, C'=G, C1'=H, C2'=Q, D'=J, D1'=K, D2'=L, E'=M, E1'=N, E2'=O, F'=1, F1'=Q_1, F2'=R, G'=S, G1'=T, G2'=U, H'=V, H1'=W, H2'=X, Q'=Y, Q1'=Z, Q2'=A1, J'=B1, J1'=C1, J2'=D1, K'=E1, K1'=F1, K2'=G1, L'=H1, L1'=Q1, L2'=J1, M'=K1, M1'=L1, M2'=M1, N'=N1, N1'=O1, N2'=P1, O'=Q1_1, O1'=R1, O2'=S1, P'=T1, P1'=U1, P2'=V1, Q_1'=W1, Q1_1'=X1, [ F>=O && P==1 ], cost: 1 10: f116 -> f116 : C'=1+C, F'=-1+F, M1'=U, N1'=1+C, O'=F, O1'=-1+F, P'=1, [ A>=2 && C>=0 && F>=0 && P==0 && U==M1 ], cost: 1 11: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 ], cost: 1 3: f1 -> f1 : B'=1+B, R'=S, S'=free_7, T'=S, [ B>=0 && Q_1>=1+B ], cost: 1 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 5: f7 -> f8 : B1'=free_17, C1'=D1, E1'=-1+free_17, F1'=-1, [ B1>=0 ], cost: 1 6: f7 -> f10 : A1'=B, A2'=C, B'=D, B1'=E, B2'=F, C'=G, C1'=H, C2'=Q, D'=J, D1'=K, D2'=L, E'=M, E1'=N, E2'=O, F'=P, F1'=Q_1, F2'=R, G'=S, G1'=T, G2'=U, H'=V, H1'=W, H2'=X, Q'=free_20, Q1'=Z, Q2'=A1, J'=B1, J1'=free_19, J2'=free_23, K'=E1, K1'=F1, K2'=free_18, L'=free_24, L1'=free_22, L2'=free_21, M'=K1, M1'=L1, M2'=M1, N'=N1, N1'=O1, N2'=P1, O'=Q1_1, O1'=R1, O2'=S1, P'=T1, P1'=U1, P2'=V1, Q_1'=W1, Q1_1'=X1, [ B1>=0 && G1==D1 ], cost: 1 7: f8 -> f8 : C1'=D1, E1'=-1+E1, G1'=0, Q1'=0, J1'=H1, K1'=-1+E1, U'=0, V'=H1, [ E1>=0 && A>=2 && Q1==0 && H1==V && G1==0 && U==0 && J1==V ], cost: 1 8: f8 -> f10 : A'=free_27, A1'=B, A2'=C, B'=D, B1'=E, B2'=F, C'=G, C1'=H, C2'=Q, D'=J, D1'=K, D2'=L, E'=M, E1'=N, E2'=O, F'=P, F1'=Q_1, F2'=R, G'=S, G1'=T, G2'=U, H'=V, H1'=W, H2'=X, Q'=free_26, Q1'=Z, Q2'=A1, J'=B1, J1'=free_31, J2'=free_25, K'=E1, K1'=F1, K2'=free_32, L'=free_30, L1'=free_29, L2'=free_28, M'=K1, M1'=L1, M2'=M1, N'=N1, N1'=O1, N2'=P1, O'=Q1_1, O1'=R1, O2'=S1, P'=T1, P1'=U1, P2'=V1, Q_1'=W1, Q1_1'=X1, [ E1>=0 && G1==D1 ], cost: 1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 13: f9 -> f10 : A'=free_47, A1'=free_41, A2'=C, B'=D, B1'=E, B2'=F, C'=G, C1'=H, C2'=Q, D'=J, D1'=K, D2'=L, E'=M, E1'=N, E2'=O, F'=0, F1'=free_53, F2'=free_40, G'=free_54, G1'=free_52, G2'=0, H'=0, H1'=free_51, H2'=free_50, Q'=free_55, Q1'=Z, Q2'=A1, J'=B1, J1'=free_49, J2'=free_48, K'=E1, K1'=F1, K2'=free_46, L'=free_45, L1'=free_44, L2'=free_43, M'=K1, M1'=L1, M2'=M1, N'=N1, N1'=O1, N2'=P1, O'=Q1_1, O1'=free_42, O2'=S1, P'=T1, P1'=U1, P2'=V1, Q_1'=W1, Q1_1'=X1, [ 0>=free_47 ], cost: 1 14: f9 -> f10 : A'=1, A1'=free_65, A2'=C, B'=D, B1'=E, B2'=F, C'=G, C1'=H, C2'=Q, D'=J, D1'=K, D2'=L, E'=M, E1'=N, E2'=O, F'=0, F1'=free_59, F2'=free_71, G'=free_57, G1'=free_72, G2'=0, H'=0, H1'=free_70, H2'=free_69, Q'=free_68, Q1'=Z, Q2'=A1, J'=B1, J1'=free_74, J2'=free_67, K'=E1, K1'=F1, K2'=free_66, L'=free_64, L1'=free_63, L2'=free_62, M'=K1, M1'=L1, M2'=M1, N'=N1, N1'=O1, N2'=P1, O'=free_61, O1'=free_60, O2'=free_58, P'=T1, P1'=U1, P2'=free_56, Q_1'=free_61, Q1_1'=free_73, [ S==0 && W==0 ], cost: 1 Checking for constant complexity: The following rule is satisfiable with cost >= 1, yielding constant complexity: 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 Removed unreachable and leaf rules: Start location: f9 10: f116 -> f116 : C'=1+C, F'=-1+F, M1'=U, N1'=1+C, O'=F, O1'=-1+F, P'=1, [ A>=2 && C>=0 && F>=0 && P==0 && U==M1 ], cost: 1 11: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 ], cost: 1 3: f1 -> f1 : B'=1+B, R'=S, S'=free_7, T'=S, [ B>=0 && Q_1>=1+B ], cost: 1 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 7: f8 -> f8 : C1'=D1, E1'=-1+E1, G1'=0, Q1'=0, J1'=H1, K1'=-1+E1, U'=0, V'=H1, [ E1>=0 && A>=2 && Q1==0 && H1==V && G1==0 && U==0 && J1==V ], cost: 1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 Removed unreachable and leaf rules: Start location: f9 10: f116 -> f116 : C'=1+C, F'=-1+F, M1'=U, N1'=1+C, O'=F, O1'=-1+F, P'=1, [ A>=2 && C>=0 && F>=0 && P==0 && U==M1 ], cost: 1 11: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 ], cost: 1 3: f1 -> f1 : B'=1+B, R'=S, S'=free_7, T'=S, [ B>=0 && Q_1>=1+B ], cost: 1 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 7: f8 -> f8 : C1'=D1, E1'=-1+E1, G1'=0, Q1'=0, J1'=H1, K1'=-1+E1, U'=0, V'=H1, [ E1>=0 && A>=2 && Q1==0 && H1==V && G1==0 && U==0 && J1==V ], cost: 1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 ### Simplification by acceleration and chaining ### Accelerating simple loops of location 2. Accelerating the following rules: 10: f116 -> f116 : C'=1+C, F'=-1+F, M1'=U, N1'=1+C, O'=F, O1'=-1+F, P'=1, [ A>=2 && C>=0 && F>=0 && P==0 && U==M1 ], cost: 1 Accelerated rule 10 with metering function -P, yielding the new rule 15. Removing the simple loops: 10. Accelerating simple loops of location 3. Accelerating the following rules: 3: f1 -> f1 : B'=1+B, R'=S, S'=free_7, T'=S, [ B>=0 && Q_1>=1+B ], cost: 1 Accelerated rule 3 with metering function Q_1-B, yielding the new rule 16. Removing the simple loops: 3. Accelerating simple loops of location 5. Accelerating the following rules: 7: f8 -> f8 : C1'=D1, E1'=-1+E1, G1'=0, Q1'=0, J1'=H1, K1'=-1+E1, U'=0, V'=H1, [ E1>=0 && A>=2 && Q1==0 && H1==V && G1==0 && U==0 && J1==V ], cost: 1 Accelerated rule 7 with metering function 1+E1, yielding the new rule 17. Removing the simple loops: 7. Accelerated all simple loops using metering functions (where possible): Start location: f9 11: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 ], cost: 1 15: f116 -> f116 : C'=C-P, F'=F+P, M1'=U, N1'=C-P, O'=1+F+P, O1'=F+P, P'=1, [ A>=2 && C>=0 && F>=0 && P==0 && U==M1 && -P>=1 ], cost: -P 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 16: f1 -> f1 : B'=Q_1, R'=free_7, S'=free_7, T'=free_7, [ B>=0 && Q_1>=1+B ], cost: Q_1-B 17: f8 -> f8 : C1'=D1, E1'=-1, G1'=0, Q1'=0, J1'=H1, K1'=-1, U'=0, V'=H1, [ E1>=0 && A>=2 && Q1==0 && H1==V && G1==0 && U==0 && J1==V ], cost: 1+E1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 Chained accelerated rules (with incoming rules): Start location: f9 11: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, G1'=0, H1'=V, Q1'=0, J1'=V, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 ], cost: 1 19: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, E1'=-1, G1'=0, H1'=V, Q1'=0, J1'=V, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 && E1>=0 ], cost: 2+E1 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 18: f9 -> f1 : A'=free_36, B'=free_36, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=free_7, R1'=free_34, S'=free_7, S1'=free_39, T'=free_7, T1'=2, U1'=free_37, W'=S, [ S==W && free_36>=3 ], cost: -1+free_36 Removed unreachable locations (and leaf rules with constant cost): Start location: f9 19: f116 -> f8 : B1'=E1, C'=1+E1, C1'=V, D1'=V, E1'=-1, G1'=0, H1'=V, Q1'=0, J1'=V, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, U'=0, [ free_33>=0 && A>=2 && C>=0 && F>=0 && U==0 && P==0 && E1>=0 ], cost: 2+E1 4: f1 -> f116 : A1'=free_16, B'=free_10, C'=0, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=R, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 ], cost: 1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 18: f9 -> f1 : A'=free_36, B'=free_36, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=free_7, R1'=free_34, S'=free_7, S1'=free_39, T'=free_7, T1'=2, U1'=free_37, W'=S, [ S==W && free_36>=3 ], cost: -1+free_36 Eliminated locations (on linear paths): Start location: f9 20: f1 -> f8 : A1'=free_16, B'=free_10, B1'=E1, C'=1+E1, C1'=R, D1'=R, E1'=-1, G1'=0, H1'=R, Q1'=0, J1'=R, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, Q_1'=free_9, R'=free_14, S'=free_8, T'=free_15, U'=0, V'=R, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ A>=2 && free_16>=A && F>=A && B>=Q_1 && B>=0 && C==0 && free_33>=0 && F>=0 && R==0 && P==0 && E1>=0 ], cost: 3+E1 12: f9 -> f1 : A'=free_36, B'=2, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=S, R1'=free_34, S'=free_35, S1'=free_39, T'=S, T1'=2, U1'=free_37, W'=S, [ free_36>=2 && S==W ], cost: 1 18: f9 -> f1 : A'=free_36, B'=free_36, P'=0, Q_1'=free_36, Q1_1'=free_38, R'=free_7, R1'=free_34, S'=free_7, S1'=free_39, T'=free_7, T1'=2, U1'=free_37, W'=S, [ S==W && free_36>=3 ], cost: -1+free_36 Eliminated locations (on tree-shaped paths): Start location: f9 21: f9 -> f8 : A'=free_36, A1'=free_16, B'=free_10, B1'=E1, C'=1+E1, C1'=S, D1'=S, E1'=-1, G1'=0, H1'=S, Q1'=0, J1'=S, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, Q_1'=free_9, Q1_1'=free_38, R'=free_14, R1'=free_34, S'=free_8, S1'=free_39, T'=free_15, T1'=2, U'=0, U1'=free_37, V'=S, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ free_36>=2 && S==W && free_16>=free_36 && F>=free_36 && 2>=free_36 && C==0 && free_33>=0 && F>=0 && S==0 && E1>=0 ], cost: 4+E1 22: f9 -> f8 : A'=free_36, A1'=free_16, B'=free_10, B1'=E1, C'=1+E1, C1'=free_7, D1'=free_7, E1'=-1, G1'=0, H1'=free_7, Q1'=0, J1'=free_7, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, Q_1'=free_9, Q1_1'=free_38, R'=free_14, R1'=free_34, S'=free_8, S1'=free_39, T'=free_15, T1'=2, U'=0, U1'=free_37, V'=free_7, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ S==W && free_36>=3 && free_16>=free_36 && F>=free_36 && C==0 && free_33>=0 && F>=0 && free_7==0 && E1>=0 ], cost: 2+E1+free_36 ### Computing asymptotic complexity ### Fully simplified ITS problem Start location: f9 21: f9 -> f8 : A'=free_36, A1'=free_16, B'=free_10, B1'=E1, C'=1+E1, C1'=S, D1'=S, E1'=-1, G1'=0, H1'=S, Q1'=0, J1'=S, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, Q_1'=free_9, Q1_1'=free_38, R'=free_14, R1'=free_34, S'=free_8, S1'=free_39, T'=free_15, T1'=2, U'=0, U1'=free_37, V'=S, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ free_36>=2 && S==W && free_16>=free_36 && F>=free_36 && 2>=free_36 && C==0 && free_33>=0 && F>=0 && S==0 && E1>=0 ], cost: 4+E1 22: f9 -> f8 : A'=free_36, A1'=free_16, B'=free_10, B1'=E1, C'=1+E1, C1'=free_7, D1'=free_7, E1'=-1, G1'=0, H1'=free_7, Q1'=0, J1'=free_7, K1'=-1, L1'=-1, O'=F, P'=1, P1'=free_33, Q_1'=free_9, Q1_1'=free_38, R'=free_14, R1'=free_34, S'=free_8, S1'=free_39, T'=free_15, T1'=2, U'=0, U1'=free_37, V'=free_7, W'=free_13, X'=free_12, Y'=free_11, Z'=free_10, [ S==W && free_36>=3 && free_16>=free_36 && F>=free_36 && C==0 && free_33>=0 && F>=0 && free_7==0 && E1>=0 ], cost: 2+E1+free_36 Computing asymptotic complexity for rule 21 Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), -1+free_36 (+/+!), 1-W+S (+/+!), 3-free_36 (+/+!), 1-S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 4+E1 (+), 1+S (+/+!), 1+C (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==0,F==2,W==0,C==0,E1==n,free_16==n,S==0,free_36==2} resulting limit problem: [solved] Solution: free_33 / 0 F / 2 W / 0 C / 0 E1 / n free_16 / n S / 0 free_36 / 2 Resulting cost 4+n has complexity: Poly(n^1) Found new complexity Poly(n^1). Computing asymptotic complexity for rule 22 Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==3,E1==n,free_16==3,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 2+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_16-free_36 (+/+!), 1 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_16-free_36 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_16==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_16-free_36 (+/+!), 1 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_16-free_36 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==n,free_16==2*n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_33 (+/+!), 1 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==0,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_33 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+free_16-free_36 (+/+!), 2+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==0,free_16==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_33 (+/+!), 1 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==2*n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {E1==0} resulting limit problem: 1+free_33 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+free_16-free_36 (+/+!), 2+free_36 (+), 1+F-free_36 (+/+!), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==n,free_16==2*n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {E1==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {E1==0,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+free_16 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), -2+free_16 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), -2+free_16 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {E1==n,free_16==n,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {E1==0,free_16==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==n,E1==n,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==3,E1==n,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==n,E1==n,free_16==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_33==0} resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {F==3,E1==n,free_16==3,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,E1==n,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,E1==0,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+free_16 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), -2+free_16 (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,E1==n,free_16==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {F==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,E1==0,free_16==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), -2+F (+/+!), 5+E1 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==n,E1==n,free_36==n} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_16==free_36} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==3,E1==n,free_36==3} resulting limit problem: [solved] Solved the limit problem by the following transformations: Created initial limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1+W-S (+/+!), 1-free_7 (+/+!), 1-W+S (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {W==S} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1-C (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), 1+C (+/+!), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {C==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1-free_7 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!), 1+free_7 (+/+!) [not solved] applying transformation rule (C) using substitution {free_7==0} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1+free_16-free_36 (+/+!), 1 (+/+!), 1+F-free_36 (+/+!), 2+E1+free_36 (+), -2+free_36 (+/+!) [not solved] applying transformation rule (C) using substitution {free_36==3} resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), 1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] applying transformation rule (B), deleting 1 (+/+!) resulting limit problem: 1+free_33 (+/+!), 1+E1 (+/+!), -2+F (+/+!), -2+free_16 (+/+!), 5+E1 (+) [not solved] removing all constraints (solved by SMT) resulting limit problem: [solved] applying transformation rule (C) using substitution {free_33==n,F==n,E1==n,free_16==n} resulting limit problem: [solved] Solution: free_33 / n F / 3 W / 0 C / 0 E1 / n free_16 / 3 S / 0 free_36 / 3 free_7 / 0 Resulting cost 5+n has complexity: Poly(n^1) Obtained the following overall complexity (w.r.t. the length of the input n): Complexity: Poly(n^1) Cpx degree: 1 Solved cost: 4+n Rule cost: 4+E1 Rule guard: [ free_36>=2 && S==W && free_16>=free_36 && F>=free_36 && 2>=free_36 && C==0 && free_33>=0 && S==0 && E1>=0 ] WORST_CASE(Omega(n^1),?) ---------------------------------------- (2) BOUNDS(n^1, INF)