Input TRS: 1: active(U11(tt,N,X,XS)) -> mark(U12(splitAt(N,XS),X)) 2: active(U12(pair(YS,ZS),X)) -> mark(pair(cons(X,YS),ZS)) 3: active(afterNth(N,XS)) -> mark(snd(splitAt(N,XS))) 4: active(and(tt,X)) -> mark(X) 5: active(fst(pair(X,Y))) -> mark(X) 6: active(head(cons(N,XS))) -> mark(N) 7: active(natsFrom(N)) -> mark(cons(N,natsFrom(s(N)))) 8: active(sel(N,XS)) -> mark(head(afterNth(N,XS))) 9: active(snd(pair(X,Y))) -> mark(Y) 10: active(splitAt(0,XS)) -> mark(pair(nil,XS)) 11: active(splitAt(s(N),cons(X,XS))) -> mark(U11(tt,N,X,XS)) 12: active(tail(cons(N,XS))) -> mark(XS) 13: active(take(N,XS)) -> mark(fst(splitAt(N,XS))) 14: mark(U11(X1,X2,X3,X4)) -> active(U11(mark(X1),X2,X3,X4)) 15: mark(tt) -> active(tt) 16: mark(U12(X1,X2)) -> active(U12(mark(X1),X2)) 17: mark(splitAt(X1,X2)) -> active(splitAt(mark(X1),mark(X2))) 18: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2))) 19: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) 20: mark(afterNth(X1,X2)) -> active(afterNth(mark(X1),mark(X2))) 21: mark(snd(X)) -> active(snd(mark(X))) 22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) 23: mark(fst(X)) -> active(fst(mark(X))) 24: mark(head(X)) -> active(head(mark(X))) 25: mark(natsFrom(X)) -> active(natsFrom(mark(X))) 26: mark(s(X)) -> active(s(mark(X))) 27: mark(sel(X1,X2)) -> active(sel(mark(X1),mark(X2))) 28: mark(0) -> active(0) 29: mark(nil) -> active(nil) 30: mark(tail(X)) -> active(tail(mark(X))) 31: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 32: U11(mark(X1),X2,X3,X4) -> U11(X1,X2,X3,X4) 33: U11(X1,mark(X2),X3,X4) -> U11(X1,X2,X3,X4) 34: U11(X1,X2,mark(X3),X4) -> U11(X1,X2,X3,X4) 35: U11(X1,X2,X3,mark(X4)) -> U11(X1,X2,X3,X4) 36: U11(active(X1),X2,X3,X4) -> U11(X1,X2,X3,X4) 37: U11(X1,active(X2),X3,X4) -> U11(X1,X2,X3,X4) 38: U11(X1,X2,active(X3),X4) -> U11(X1,X2,X3,X4) 39: U11(X1,X2,X3,active(X4)) -> U11(X1,X2,X3,X4) 40: U12(mark(X1),X2) -> U12(X1,X2) 41: U12(X1,mark(X2)) -> U12(X1,X2) 42: U12(active(X1),X2) -> U12(X1,X2) 43: U12(X1,active(X2)) -> U12(X1,X2) 44: splitAt(mark(X1),X2) -> splitAt(X1,X2) 45: splitAt(X1,mark(X2)) -> splitAt(X1,X2) 46: splitAt(active(X1),X2) -> splitAt(X1,X2) 47: splitAt(X1,active(X2)) -> splitAt(X1,X2) 48: pair(mark(X1),X2) -> pair(X1,X2) 49: pair(X1,mark(X2)) -> pair(X1,X2) 50: pair(active(X1),X2) -> pair(X1,X2) 51: pair(X1,active(X2)) -> pair(X1,X2) 52: cons(mark(X1),X2) -> cons(X1,X2) 53: cons(X1,mark(X2)) -> cons(X1,X2) 54: cons(active(X1),X2) -> cons(X1,X2) 55: cons(X1,active(X2)) -> cons(X1,X2) 56: afterNth(mark(X1),X2) -> afterNth(X1,X2) 57: afterNth(X1,mark(X2)) -> afterNth(X1,X2) 58: afterNth(active(X1),X2) -> afterNth(X1,X2) 59: afterNth(X1,active(X2)) -> afterNth(X1,X2) 60: snd(mark(X)) -> snd(X) 61: snd(active(X)) -> snd(X) 62: and(mark(X1),X2) -> and(X1,X2) 63: and(X1,mark(X2)) -> and(X1,X2) 64: and(active(X1),X2) -> and(X1,X2) 65: and(X1,active(X2)) -> and(X1,X2) 66: fst(mark(X)) -> fst(X) 67: fst(active(X)) -> fst(X) 68: head(mark(X)) -> head(X) 69: head(active(X)) -> head(X) 70: natsFrom(mark(X)) -> natsFrom(X) 71: natsFrom(active(X)) -> natsFrom(X) 72: s(mark(X)) -> s(X) 73: s(active(X)) -> s(X) 74: sel(mark(X1),X2) -> sel(X1,X2) 75: sel(X1,mark(X2)) -> sel(X1,X2) 76: sel(active(X1),X2) -> sel(X1,X2) 77: sel(X1,active(X2)) -> sel(X1,X2) 78: tail(mark(X)) -> tail(X) 79: tail(active(X)) -> tail(X) 80: take(mark(X1),X2) -> take(X1,X2) 81: take(X1,mark(X2)) -> take(X1,X2) 82: take(active(X1),X2) -> take(X1,X2) 83: take(X1,active(X2)) -> take(X1,X2) Dependency Pairs: #1: #active(U11(tt,N,X,XS)) -> #mark(U12(splitAt(N,XS),X)) #2: #active(U11(tt,N,X,XS)) -> #U12(splitAt(N,XS),X) #3: #active(U11(tt,N,X,XS)) -> #splitAt(N,XS) #4: #active(U12(pair(YS,ZS),X)) -> #mark(pair(cons(X,YS),ZS)) #5: #active(U12(pair(YS,ZS),X)) -> #pair(cons(X,YS),ZS) #6: #active(U12(pair(YS,ZS),X)) -> #cons(X,YS) #7: #active(afterNth(N,XS)) -> #mark(snd(splitAt(N,XS))) #8: #active(afterNth(N,XS)) -> #snd(splitAt(N,XS)) #9: #active(afterNth(N,XS)) -> #splitAt(N,XS) #10: #active(and(tt,X)) -> #mark(X) #11: #active(fst(pair(X,Y))) -> #mark(X) #12: #active(head(cons(N,XS))) -> #mark(N) #13: #active(natsFrom(N)) -> #mark(cons(N,natsFrom(s(N)))) #14: #active(natsFrom(N)) -> #cons(N,natsFrom(s(N))) #15: #active(natsFrom(N)) -> #natsFrom(s(N)) #16: #active(natsFrom(N)) -> #s(N) #17: #active(sel(N,XS)) -> #mark(head(afterNth(N,XS))) #18: #active(sel(N,XS)) -> #head(afterNth(N,XS)) #19: #active(sel(N,XS)) -> #afterNth(N,XS) #20: #active(snd(pair(X,Y))) -> #mark(Y) #21: #active(splitAt(0,XS)) -> #mark(pair(nil,XS)) #22: #active(splitAt(0,XS)) -> #pair(nil,XS) #23: #active(splitAt(s(N),cons(X,XS))) -> #mark(U11(tt,N,X,XS)) #24: #active(splitAt(s(N),cons(X,XS))) -> #U11(tt,N,X,XS) #25: #active(tail(cons(N,XS))) -> #mark(XS) #26: #active(take(N,XS)) -> #mark(fst(splitAt(N,XS))) #27: #active(take(N,XS)) -> #fst(splitAt(N,XS)) #28: #active(take(N,XS)) -> #splitAt(N,XS) #29: #mark(U11(X1,X2,X3,X4)) -> #active(U11(mark(X1),X2,X3,X4)) #30: #mark(U11(X1,X2,X3,X4)) -> #U11(mark(X1),X2,X3,X4) #31: #mark(U11(X1,X2,X3,X4)) -> #mark(X1) #32: #mark(tt) -> #active(tt) #33: #mark(U12(X1,X2)) -> #active(U12(mark(X1),X2)) #34: #mark(U12(X1,X2)) -> #U12(mark(X1),X2) #35: #mark(U12(X1,X2)) -> #mark(X1) #36: #mark(splitAt(X1,X2)) -> #active(splitAt(mark(X1),mark(X2))) #37: #mark(splitAt(X1,X2)) -> #splitAt(mark(X1),mark(X2)) #38: #mark(splitAt(X1,X2)) -> #mark(X1) #39: #mark(splitAt(X1,X2)) -> #mark(X2) #40: #mark(pair(X1,X2)) -> #active(pair(mark(X1),mark(X2))) #41: #mark(pair(X1,X2)) -> #pair(mark(X1),mark(X2)) #42: #mark(pair(X1,X2)) -> #mark(X1) #43: #mark(pair(X1,X2)) -> #mark(X2) #44: #mark(cons(X1,X2)) -> #active(cons(mark(X1),X2)) #45: #mark(cons(X1,X2)) -> #cons(mark(X1),X2) #46: #mark(cons(X1,X2)) -> #mark(X1) #47: #mark(afterNth(X1,X2)) -> #active(afterNth(mark(X1),mark(X2))) #48: #mark(afterNth(X1,X2)) -> #afterNth(mark(X1),mark(X2)) #49: #mark(afterNth(X1,X2)) -> #mark(X1) #50: #mark(afterNth(X1,X2)) -> #mark(X2) #51: #mark(snd(X)) -> #active(snd(mark(X))) #52: #mark(snd(X)) -> #snd(mark(X)) #53: #mark(snd(X)) -> #mark(X) #54: #mark(and(X1,X2)) -> #active(and(mark(X1),X2)) #55: #mark(and(X1,X2)) -> #and(mark(X1),X2) #56: #mark(and(X1,X2)) -> #mark(X1) #57: #mark(fst(X)) -> #active(fst(mark(X))) #58: #mark(fst(X)) -> #fst(mark(X)) #59: #mark(fst(X)) -> #mark(X) #60: #mark(head(X)) -> #active(head(mark(X))) #61: #mark(head(X)) -> #head(mark(X)) #62: #mark(head(X)) -> #mark(X) #63: #mark(natsFrom(X)) -> #active(natsFrom(mark(X))) #64: #mark(natsFrom(X)) -> #natsFrom(mark(X)) #65: #mark(natsFrom(X)) -> #mark(X) #66: #mark(s(X)) -> #active(s(mark(X))) #67: #mark(s(X)) -> #s(mark(X)) #68: #mark(s(X)) -> #mark(X) #69: #mark(sel(X1,X2)) -> #active(sel(mark(X1),mark(X2))) #70: #mark(sel(X1,X2)) -> #sel(mark(X1),mark(X2)) #71: #mark(sel(X1,X2)) -> #mark(X1) #72: #mark(sel(X1,X2)) -> #mark(X2) #73: #mark(0) -> #active(0) #74: #mark(nil) -> #active(nil) #75: #mark(tail(X)) -> #active(tail(mark(X))) #76: #mark(tail(X)) -> #tail(mark(X)) #77: #mark(tail(X)) -> #mark(X) #78: #mark(take(X1,X2)) -> #active(take(mark(X1),mark(X2))) #79: #mark(take(X1,X2)) -> #take(mark(X1),mark(X2)) #80: #mark(take(X1,X2)) -> #mark(X1) #81: #mark(take(X1,X2)) -> #mark(X2) #82: #U11(mark(X1),X2,X3,X4) -> #U11(X1,X2,X3,X4) #83: #U11(X1,mark(X2),X3,X4) -> #U11(X1,X2,X3,X4) #84: #U11(X1,X2,mark(X3),X4) -> #U11(X1,X2,X3,X4) #85: #U11(X1,X2,X3,mark(X4)) -> #U11(X1,X2,X3,X4) #86: #U11(active(X1),X2,X3,X4) -> #U11(X1,X2,X3,X4) #87: #U11(X1,active(X2),X3,X4) -> #U11(X1,X2,X3,X4) #88: #U11(X1,X2,active(X3),X4) -> #U11(X1,X2,X3,X4) #89: #U11(X1,X2,X3,active(X4)) -> #U11(X1,X2,X3,X4) #90: #U12(mark(X1),X2) -> #U12(X1,X2) #91: #U12(X1,mark(X2)) -> #U12(X1,X2) #92: #U12(active(X1),X2) -> #U12(X1,X2) #93: #U12(X1,active(X2)) -> #U12(X1,X2) #94: #splitAt(mark(X1),X2) -> #splitAt(X1,X2) #95: #splitAt(X1,mark(X2)) -> #splitAt(X1,X2) #96: #splitAt(active(X1),X2) -> #splitAt(X1,X2) #97: #splitAt(X1,active(X2)) -> #splitAt(X1,X2) #98: #pair(mark(X1),X2) -> #pair(X1,X2) #99: #pair(X1,mark(X2)) -> #pair(X1,X2) #100: #pair(active(X1),X2) -> #pair(X1,X2) #101: #pair(X1,active(X2)) -> #pair(X1,X2) #102: #cons(mark(X1),X2) -> #cons(X1,X2) #103: #cons(X1,mark(X2)) -> #cons(X1,X2) #104: #cons(active(X1),X2) -> #cons(X1,X2) #105: #cons(X1,active(X2)) -> #cons(X1,X2) #106: #afterNth(mark(X1),X2) -> #afterNth(X1,X2) #107: #afterNth(X1,mark(X2)) -> #afterNth(X1,X2) #108: #afterNth(active(X1),X2) -> #afterNth(X1,X2) #109: #afterNth(X1,active(X2)) -> #afterNth(X1,X2) #110: #snd(mark(X)) -> #snd(X) #111: #snd(active(X)) -> #snd(X) #112: #and(mark(X1),X2) -> #and(X1,X2) #113: #and(X1,mark(X2)) -> #and(X1,X2) #114: #and(active(X1),X2) -> #and(X1,X2) #115: #and(X1,active(X2)) -> #and(X1,X2) #116: #fst(mark(X)) -> #fst(X) #117: #fst(active(X)) -> #fst(X) #118: #head(mark(X)) -> #head(X) #119: #head(active(X)) -> #head(X) #120: #natsFrom(mark(X)) -> #natsFrom(X) #121: #natsFrom(active(X)) -> #natsFrom(X) #122: #s(mark(X)) -> #s(X) #123: #s(active(X)) -> #s(X) #124: #sel(mark(X1),X2) -> #sel(X1,X2) #125: #sel(X1,mark(X2)) -> #sel(X1,X2) #126: #sel(active(X1),X2) -> #sel(X1,X2) #127: #sel(X1,active(X2)) -> #sel(X1,X2) #128: #tail(mark(X)) -> #tail(X) #129: #tail(active(X)) -> #tail(X) #130: #take(mark(X1),X2) -> #take(X1,X2) #131: #take(X1,mark(X2)) -> #take(X1,X2) #132: #take(active(X1),X2) -> #take(X1,X2) #133: #take(X1,active(X2)) -> #take(X1,X2) Number of SCCs: 16 SCC { #110 #111 } QKBOPS(sum)... removes: #110 #111 I(active) = x1 \pi(active) = [1] I(mark) = 1 + x1 \pi(mark) = [] I(#snd) = x1 \pi(#snd) = [1] PREC: active = mark = #snd USABLE RULES: { } Number of SCCs: 15 SCC { #120 #121 } QKBOPS(sum)... removes: #120 #121 I(#natsFrom) = x1 \pi(#natsFrom) = 1 I(active) = x1 \pi(active) = [1] I(mark) = 1 + x1 \pi(mark) = [] PREC: active = mark USABLE RULES: { } Number of SCCs: 14 SCC { #122 #123 } QKBOPS(sum)... removes: #122 #123 I(active) = x1 \pi(active) = [1] I(#s) = x1 \pi(#s) = [1] I(mark) = 1 + x1 \pi(mark) = [] PREC: active = #s = mark USABLE RULES: { } Number of SCCs: 13 SCC { #118 #119 } QKBOPS(sum)... removes: #118 #119 I(active) = x1 \pi(active) = [1] I(#head) = x1 \pi(#head) = [1] I(mark) = 1 + x1 \pi(mark) = [] PREC: active = #head = mark USABLE RULES: { } Number of SCCs: 12 SCC { #116 #117 } QKBOPS(sum)... removes: #116 #117 I(active) = x1 \pi(active) = [1] I(#fst) = x1 \pi(#fst) = [1] I(mark) = 1 + x1 \pi(mark) = [] PREC: active = #fst = mark USABLE RULES: { } Number of SCCs: 11 SCC { #128 #129 } QKBOPS(sum)... removes: #128 #129 I(active) = x1 \pi(active) = [1] I(#tail) = x1 \pi(#tail) = [1] I(mark) = 1 + x1 \pi(mark) = [] PREC: active = #tail = mark USABLE RULES: { } Number of SCCs: 10 SCC { #94 #95 #96 #97 } QKBOPS(sum)... removes: #95 I(#splitAt) = x2 \pi(#splitAt) = [] I(active) = x1 \pi(active) = [] I(mark) = 1 + x1 \pi(mark) = [] PREC: #splitAt = active = mark USABLE RULES: { } Number of SCCs: 10 SCC { #94 #96 #97 } QKBOPS(sum)... removes: #94 I(#splitAt) = 2 + x1 \pi(#splitAt) = [] I(active) = x1 \pi(active) = [] I(mark) = 1 + x1 \pi(mark) = [] PREC: #splitAt = mark > active USABLE RULES: { } Number of SCCs: 10 SCC { #96 #97 } QKBOPS(sum)... removes: #96 #97 I(#splitAt) = 1 + x1 + x2 \pi(#splitAt) = [1] I(active) = 2 + x1 \pi(active) = [] PREC: #splitAt > active USABLE RULES: { } Number of SCCs: 9 SCC { #98 #99 #100 #101 } QKBOPS(sum)... removes: #99 I(#pair) = x2 \pi(#pair) = [] I(active) = x1 \pi(active) = [] I(mark) = 1 + x1 \pi(mark) = [] PREC: #pair = active = mark USABLE RULES: { } Number of SCCs: 9 SCC { #98 #100 #101 } QKBOPS(sum)... removes: #98 I(#pair) = 2 + x1 \pi(#pair) = [] I(active) = x1 \pi(active) = [] I(mark) = 1 + x1 \pi(mark) = [] PREC: #pair = mark > active USABLE RULES: { } Number of SCCs: 9 SCC { #100 #101 } QKBOPS(sum)... removes: #100 #101 I(#pair) = 1 + x1 + x2 \pi(#pair) = [1] I(active) = 2 + x1 \pi(active) = [] PREC: #pair > active USABLE RULES: { } Number of SCCs: 8 SCC { #90 #91 #92 #93 } QKBOPS(sum)... removes: #92 #93 I(active) = 1 + x1 \pi(active) = [] I(#U12) = 2 + x1 + x2 \pi(#U12) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #U12 > active USABLE RULES: { } Number of SCCs: 8 SCC { #90 #91 } QKBOPS(sum)... removes: #90 #91 I(#U12) = 1 + x1 + x2 \pi(#U12) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #U12 > mark USABLE RULES: { } Number of SCCs: 7 SCC { #102 #103 #104 #105 } QKBOPS(sum)... removes: #104 #105 I(active) = 1 + x1 \pi(active) = [] I(#cons) = 2 + x1 + x2 \pi(#cons) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #cons > active USABLE RULES: { } Number of SCCs: 7 SCC { #102 #103 } QKBOPS(sum)... removes: #102 #103 I(#cons) = 1 + x1 + x2 \pi(#cons) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #cons > mark USABLE RULES: { } Number of SCCs: 6 SCC { #106 #107 #108 #109 } QKBOPS(sum)... removes: #108 #109 I(active) = 1 + x1 \pi(active) = [] I(#afterNth) = 2 + x1 + x2 \pi(#afterNth) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #afterNth > active USABLE RULES: { } Number of SCCs: 6 SCC { #106 #107 } QKBOPS(sum)... removes: #106 #107 I(#afterNth) = 1 + x1 + x2 \pi(#afterNth) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #afterNth > mark USABLE RULES: { } Number of SCCs: 5 SCC { #112 #113 #114 #115 } QKBOPS(sum)... removes: #114 #115 I(active) = 1 + x1 \pi(active) = [] I(#and) = 2 + x1 + x2 \pi(#and) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #and > active USABLE RULES: { } Number of SCCs: 5 SCC { #112 #113 } QKBOPS(sum)... removes: #112 #113 I(#and) = 1 + x1 + x2 \pi(#and) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #and > mark USABLE RULES: { } Number of SCCs: 4 SCC { #124 #125 #126 #127 } QKBOPS(sum)... removes: #126 #127 I(active) = 1 + x1 \pi(active) = [] I(#sel) = 2 + x1 + x2 \pi(#sel) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #sel > active USABLE RULES: { } Number of SCCs: 4 SCC { #124 #125 } QKBOPS(sum)... removes: #124 #125 I(#sel) = 1 + x1 + x2 \pi(#sel) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #sel > mark USABLE RULES: { } Number of SCCs: 3 SCC { #130 #131 #132 #133 } QKBOPS(sum)... removes: #132 #133 I(active) = 1 + x1 \pi(active) = [] I(#take) = 2 + x1 + x2 \pi(#take) = [1] I(mark) = x1 \pi(mark) = [] PREC: mark > #take > active USABLE RULES: { } Number of SCCs: 3 SCC { #130 #131 } QKBOPS(sum)... removes: #130 #131 I(#take) = 1 + x1 + x2 \pi(#take) = [1] I(mark) = 2 + x1 \pi(mark) = [] PREC: #take > mark USABLE RULES: { } Number of SCCs: 2 SCC { #82 #83 #84 #85 #86 #87 #88 #89 } QKBOPS(sum)... removes: #82 #85 I(active) = x1 \pi(active) = [] I(#U11) = 2 + x1 + x4 \pi(#U11) = [4,1] I(mark) = 3 + x1 \pi(mark) = [1] PREC: active > #U11 = mark USABLE RULES: { } Number of SCCs: 2 SCC { #83 #84 #86 #87 #88 #89 } QKBOPS(sum)... removes: #89 I(active) = 1 + x1 \pi(active) = [] I(#U11) = x4 \pi(#U11) = 4 I(mark) = 1 + x1 \pi(mark) = [] PREC: active = mark USABLE RULES: { } Number of SCCs: 2 SCC { #83 #84 #86 #87 #88 } QKBOPS(sum)... removes: #83 #84 #86 #87 #88 I(active) = 1 + x1 \pi(active) = [] I(#U11) = 2 + x1 + x2 + x3 \pi(#U11) = [3,1,2] I(mark) = 3 + x1 \pi(mark) = [] PREC: active = #U11 > mark USABLE RULES: { } Number of SCCs: 1 SCC { #1 #4 #7 #10 #11 #12 #13 #17 #20 #21 #23 #25 #26 #29 #31 #33 #35 #36 #38 #39 #40 #42 #43 #44 #46 #47 #49 #50 #51 #53 #54 #56 #57 #59 #60 #62 #63 #65 #66 #68 #69 #71 #72 #75 #77 #78 #80 #81 } QKBOPS(sum)... removes: #40 #44 #66 I(natsFrom) = 4 \pi(natsFrom) = [] I(cons) = 3 \pi(cons) = [] I(afterNth) = 4 \pi(afterNth) = [] I(active) = 9 \pi(active) = [] I(#mark) = 4 \pi(#mark) = [] I(tt) = 10 I(0) = 1 I(U11) = 4 \pi(U11) = [] I(U12) = 4 \pi(U12) = [] I(fst) = 4 \pi(fst) = [] I(s) = 3 \pi(s) = [] I(#active) = x1 \pi(#active) = 1 I(nil) = 2 I(splitAt) = 4 \pi(splitAt) = [] I(pair) = 2 \pi(pair) = [] I(sel) = 4 \pi(sel) = [] I(and) = 4 \pi(and) = [] I(snd) = 4 \pi(snd) = [] I(mark) = 4 + x1 \pi(mark) = [] I(take) = 4 \pi(take) = [] I(head) = 4 \pi(head) = [] I(tail) = 4 \pi(tail) = [] PREC: natsFrom = afterNth = #mark = tt = U11 = U12 = fst = s = splitAt = sel = and = snd = take = head = tail > cons > active = mark > pair > 0 > nil USABLE RULES: { 83..32 } Number of SCCs: 1 SCC { #1 #4 #7 #10 #11 #12 #13 #17 #20 #21 #23 #25 #26 #29 #31 #33 #35 #36 #38 #39 #42 #43 #46 #47 #49 #50 #51 #53 #54 #56 #57 #59 #60 #62 #63 #65 #68 #69 #71 #72 #75 #77 #78 #80 #81 } QKBOPS(sum)... failed.