/export/starexec/sandbox/solver/bin/starexec_run_standard /export/starexec/sandbox/benchmark/theBenchmark.hs /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES
proof of /export/starexec/sandbox/benchmark/theBenchmark.hs
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


H-Termination with start terms of the given HASKELL could be proven:

(0) HASKELL
(1) BR [EQUIVALENT, 0 ms]
(2) HASKELL
(3) COR [EQUIVALENT, 0 ms]
(4) HASKELL
(5) Narrow [SOUND, 0 ms]
(6) QDP
(7) DependencyGraphProof [EQUIVALENT, 0 ms]
(8) AND
    (9) QDP
        (10) MRRProof [EQUIVALENT, 96 ms]
        (11) QDP
        (12) TransformationProof [EQUIVALENT, 0 ms]
        (13) QDP
        (14) QReductionProof [EQUIVALENT, 0 ms]
        (15) QDP
        (16) TransformationProof [EQUIVALENT, 0 ms]
        (17) QDP
        (18) TransformationProof [EQUIVALENT, 0 ms]
        (19) QDP
        (20) UsableRulesProof [EQUIVALENT, 0 ms]
        (21) QDP
        (22) QReductionProof [EQUIVALENT, 0 ms]
        (23) QDP
        (24) TransformationProof [EQUIVALENT, 0 ms]
        (25) QDP
        (26) UsableRulesProof [EQUIVALENT, 0 ms]
        (27) QDP
        (28) QReductionProof [EQUIVALENT, 0 ms]
        (29) QDP
        (30) QDPOrderProof [EQUIVALENT, 26 ms]
        (31) QDP
        (32) TransformationProof [EQUIVALENT, 0 ms]
        (33) QDP
        (34) DependencyGraphProof [EQUIVALENT, 0 ms]
        (35) TRUE
    (36) QDP
        (37) QDPPairToRuleProof [EQUIVALENT, 0 ms]
        (38) AND
            (39) QDP
                (40) TransformationProof [EQUIVALENT, 0 ms]
                (41) QDP
                (42) DependencyGraphProof [EQUIVALENT, 0 ms]
                (43) QDP
                (44) UsableRulesProof [EQUIVALENT, 0 ms]
                (45) QDP
                (46) QReductionProof [EQUIVALENT, 0 ms]
                (47) QDP
                (48) InductionCalculusProof [EQUIVALENT, 0 ms]
                (49) QDP
                (50) NonInfProof [EQUIVALENT, 97 ms]
                (51) QDP
                (52) DependencyGraphProof [EQUIVALENT, 0 ms]
                (53) TRUE
            (54) QDP
                (55) QDPSizeChangeProof [EQUIVALENT, 0 ms]
                (56) YES
    (57) QDP
        (58) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (59) YES
    (60) QDP
        (61) QDPSizeChangeProof [EQUIVALENT, 0 ms]
        (62) YES


----------------------------------------

(0)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
data List a = Cons a (List a)  | Nil ;

data MyBool = MyTrue  | MyFalse ;

data MyInt = Pos Main.Nat  | Neg Main.Nat ;

data Main.Nat = Succ Main.Nat  | Zero ;

data Ordering = LT  | EQ  | GT ;

data Main.WHNF a = WHNF a ;

compareMyInt :: MyInt  ->  MyInt  ->  Ordering;
compareMyInt = primCmpInt;

dsEm :: (a  ->  b)  ->  a  ->  b;
dsEm f x = Main.seq x (f x);

enforceWHNF :: Main.WHNF b  ->  a  ->  a;
enforceWHNF (Main.WHNF x) y = y;

enumFromToMyInt :: MyInt  ->  MyInt  ->  List MyInt;
enumFromToMyInt = numericEnumFromTo;

esEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
esEsOrdering LT LT = MyTrue;
esEsOrdering LT EQ = MyFalse;
esEsOrdering LT GT = MyFalse;
esEsOrdering EQ LT = MyFalse;
esEsOrdering EQ EQ = MyTrue;
esEsOrdering EQ GT = MyFalse;
esEsOrdering GT LT = MyFalse;
esEsOrdering GT EQ = MyFalse;
esEsOrdering GT GT = MyTrue;

flip :: (c  ->  b  ->  a)  ->  b  ->  c  ->  a;
flip f x y = f y x;

fromIntMyInt :: MyInt  ->  MyInt;
fromIntMyInt x = x;

fsEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
fsEsOrdering x y = not (esEsOrdering x y);

ltEsMyInt :: MyInt  ->  MyInt  ->  MyBool;
ltEsMyInt x y = fsEsOrdering (compareMyInt x y) GT;

not :: MyBool  ->  MyBool;
not MyTrue = MyFalse;
not MyFalse = MyTrue;

numericEnumFrom n = Cons n (dsEm numericEnumFrom (psMyInt n (fromIntMyInt (Main.Pos (Main.Succ Main.Zero)))));

numericEnumFromTo n m = takeWhile (flip ltEsMyInt m) (numericEnumFrom n);

otherwise :: MyBool;
otherwise = MyTrue;

primCmpInt :: MyInt  ->  MyInt  ->  Ordering;
primCmpInt (Main.Pos Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Pos Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Pos x) (Main.Pos y) = primCmpNat x y;
primCmpInt (Main.Pos x) (Main.Neg y) = GT;
primCmpInt (Main.Neg x) (Main.Pos y) = LT;
primCmpInt (Main.Neg x) (Main.Neg y) = primCmpNat y x;

primCmpNat :: Main.Nat  ->  Main.Nat  ->  Ordering;
primCmpNat Main.Zero Main.Zero = EQ;
primCmpNat Main.Zero (Main.Succ y) = LT;
primCmpNat (Main.Succ x) Main.Zero = GT;
primCmpNat (Main.Succ x) (Main.Succ y) = primCmpNat x y;

primMinusNat :: Main.Nat  ->  Main.Nat  ->  MyInt;
primMinusNat Main.Zero Main.Zero = Main.Pos Main.Zero;
primMinusNat Main.Zero (Main.Succ y) = Main.Neg (Main.Succ y);
primMinusNat (Main.Succ x) Main.Zero = Main.Pos (Main.Succ x);
primMinusNat (Main.Succ x) (Main.Succ y) = primMinusNat x y;

primPlusInt :: MyInt  ->  MyInt  ->  MyInt;
primPlusInt (Main.Pos x) (Main.Neg y) = primMinusNat x y;
primPlusInt (Main.Neg x) (Main.Pos y) = primMinusNat y x;
primPlusInt (Main.Neg x) (Main.Neg y) = Main.Neg (primPlusNat x y);
primPlusInt (Main.Pos x) (Main.Pos y) = Main.Pos (primPlusNat x y);

primPlusNat :: Main.Nat  ->  Main.Nat  ->  Main.Nat;
primPlusNat Main.Zero Main.Zero = Main.Zero;
primPlusNat Main.Zero (Main.Succ y) = Main.Succ y;
primPlusNat (Main.Succ x) Main.Zero = Main.Succ x;
primPlusNat (Main.Succ x) (Main.Succ y) = Main.Succ (Main.Succ (primPlusNat x y));

psMyInt :: MyInt  ->  MyInt  ->  MyInt;
psMyInt = primPlusInt;

seq :: a  ->  b  ->  b;
seq x y = Main.enforceWHNF (Main.WHNF x) y;

takeWhile :: (a  ->  MyBool)  ->  List a  ->  List a;
takeWhile p Nil = takeWhile3 p Nil;
takeWhile p (Cons x xs) = takeWhile2 p (Cons x xs);

takeWhile0 p x xs MyTrue = Nil;

takeWhile1 p x xs MyTrue = Cons x (takeWhile p xs);
takeWhile1 p x xs MyFalse = takeWhile0 p x xs otherwise;

takeWhile2 p (Cons x xs) = takeWhile1 p x xs (p x);

takeWhile3 p Nil = Nil;
takeWhile3 vx vy = takeWhile2 vx vy;

}

----------------------------------------

(1) BR (EQUIVALENT)
Replaced joker patterns by fresh variables and removed binding patterns.
----------------------------------------

(2)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
data List a = Cons a (List a)  | Nil ;

data MyBool = MyTrue  | MyFalse ;

data MyInt = Pos Main.Nat  | Neg Main.Nat ;

data Main.Nat = Succ Main.Nat  | Zero ;

data Ordering = LT  | EQ  | GT ;

data Main.WHNF a = WHNF a ;

compareMyInt :: MyInt  ->  MyInt  ->  Ordering;
compareMyInt = primCmpInt;

dsEm :: (b  ->  a)  ->  b  ->  a;
dsEm f x = Main.seq x (f x);

enforceWHNF :: Main.WHNF b  ->  a  ->  a;
enforceWHNF (Main.WHNF x) y = y;

enumFromToMyInt :: MyInt  ->  MyInt  ->  List MyInt;
enumFromToMyInt = numericEnumFromTo;

esEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
esEsOrdering LT LT = MyTrue;
esEsOrdering LT EQ = MyFalse;
esEsOrdering LT GT = MyFalse;
esEsOrdering EQ LT = MyFalse;
esEsOrdering EQ EQ = MyTrue;
esEsOrdering EQ GT = MyFalse;
esEsOrdering GT LT = MyFalse;
esEsOrdering GT EQ = MyFalse;
esEsOrdering GT GT = MyTrue;

flip :: (c  ->  b  ->  a)  ->  b  ->  c  ->  a;
flip f x y = f y x;

fromIntMyInt :: MyInt  ->  MyInt;
fromIntMyInt x = x;

fsEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
fsEsOrdering x y = not (esEsOrdering x y);

ltEsMyInt :: MyInt  ->  MyInt  ->  MyBool;
ltEsMyInt x y = fsEsOrdering (compareMyInt x y) GT;

not :: MyBool  ->  MyBool;
not MyTrue = MyFalse;
not MyFalse = MyTrue;

numericEnumFrom n = Cons n (dsEm numericEnumFrom (psMyInt n (fromIntMyInt (Main.Pos (Main.Succ Main.Zero)))));

numericEnumFromTo n m = takeWhile (flip ltEsMyInt m) (numericEnumFrom n);

otherwise :: MyBool;
otherwise = MyTrue;

primCmpInt :: MyInt  ->  MyInt  ->  Ordering;
primCmpInt (Main.Pos Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Pos Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Pos x) (Main.Pos y) = primCmpNat x y;
primCmpInt (Main.Pos x) (Main.Neg y) = GT;
primCmpInt (Main.Neg x) (Main.Pos y) = LT;
primCmpInt (Main.Neg x) (Main.Neg y) = primCmpNat y x;

primCmpNat :: Main.Nat  ->  Main.Nat  ->  Ordering;
primCmpNat Main.Zero Main.Zero = EQ;
primCmpNat Main.Zero (Main.Succ y) = LT;
primCmpNat (Main.Succ x) Main.Zero = GT;
primCmpNat (Main.Succ x) (Main.Succ y) = primCmpNat x y;

primMinusNat :: Main.Nat  ->  Main.Nat  ->  MyInt;
primMinusNat Main.Zero Main.Zero = Main.Pos Main.Zero;
primMinusNat Main.Zero (Main.Succ y) = Main.Neg (Main.Succ y);
primMinusNat (Main.Succ x) Main.Zero = Main.Pos (Main.Succ x);
primMinusNat (Main.Succ x) (Main.Succ y) = primMinusNat x y;

primPlusInt :: MyInt  ->  MyInt  ->  MyInt;
primPlusInt (Main.Pos x) (Main.Neg y) = primMinusNat x y;
primPlusInt (Main.Neg x) (Main.Pos y) = primMinusNat y x;
primPlusInt (Main.Neg x) (Main.Neg y) = Main.Neg (primPlusNat x y);
primPlusInt (Main.Pos x) (Main.Pos y) = Main.Pos (primPlusNat x y);

primPlusNat :: Main.Nat  ->  Main.Nat  ->  Main.Nat;
primPlusNat Main.Zero Main.Zero = Main.Zero;
primPlusNat Main.Zero (Main.Succ y) = Main.Succ y;
primPlusNat (Main.Succ x) Main.Zero = Main.Succ x;
primPlusNat (Main.Succ x) (Main.Succ y) = Main.Succ (Main.Succ (primPlusNat x y));

psMyInt :: MyInt  ->  MyInt  ->  MyInt;
psMyInt = primPlusInt;

seq :: a  ->  b  ->  b;
seq x y = Main.enforceWHNF (Main.WHNF x) y;

takeWhile :: (a  ->  MyBool)  ->  List a  ->  List a;
takeWhile p Nil = takeWhile3 p Nil;
takeWhile p (Cons x xs) = takeWhile2 p (Cons x xs);

takeWhile0 p x xs MyTrue = Nil;

takeWhile1 p x xs MyTrue = Cons x (takeWhile p xs);
takeWhile1 p x xs MyFalse = takeWhile0 p x xs otherwise;

takeWhile2 p (Cons x xs) = takeWhile1 p x xs (p x);

takeWhile3 p Nil = Nil;
takeWhile3 vx vy = takeWhile2 vx vy;

}

----------------------------------------

(3) COR (EQUIVALENT)
Cond Reductions:
The following Function with conditions
"undefined |Falseundefined;
"
is transformed to
"undefined  = undefined1;
"
"undefined0 True = undefined;
"
"undefined1  = undefined0 False;
"

----------------------------------------

(4)
Obligation:
mainModule Main 
module Main where {
import qualified Prelude;
data List a = Cons a (List a)  | Nil ;

data MyBool = MyTrue  | MyFalse ;

data MyInt = Pos Main.Nat  | Neg Main.Nat ;

data Main.Nat = Succ Main.Nat  | Zero ;

data Ordering = LT  | EQ  | GT ;

data Main.WHNF a = WHNF a ;

compareMyInt :: MyInt  ->  MyInt  ->  Ordering;
compareMyInt = primCmpInt;

dsEm :: (b  ->  a)  ->  b  ->  a;
dsEm f x = Main.seq x (f x);

enforceWHNF :: Main.WHNF b  ->  a  ->  a;
enforceWHNF (Main.WHNF x) y = y;

enumFromToMyInt :: MyInt  ->  MyInt  ->  List MyInt;
enumFromToMyInt = numericEnumFromTo;

esEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
esEsOrdering LT LT = MyTrue;
esEsOrdering LT EQ = MyFalse;
esEsOrdering LT GT = MyFalse;
esEsOrdering EQ LT = MyFalse;
esEsOrdering EQ EQ = MyTrue;
esEsOrdering EQ GT = MyFalse;
esEsOrdering GT LT = MyFalse;
esEsOrdering GT EQ = MyFalse;
esEsOrdering GT GT = MyTrue;

flip :: (a  ->  b  ->  c)  ->  b  ->  a  ->  c;
flip f x y = f y x;

fromIntMyInt :: MyInt  ->  MyInt;
fromIntMyInt x = x;

fsEsOrdering :: Ordering  ->  Ordering  ->  MyBool;
fsEsOrdering x y = not (esEsOrdering x y);

ltEsMyInt :: MyInt  ->  MyInt  ->  MyBool;
ltEsMyInt x y = fsEsOrdering (compareMyInt x y) GT;

not :: MyBool  ->  MyBool;
not MyTrue = MyFalse;
not MyFalse = MyTrue;

numericEnumFrom n = Cons n (dsEm numericEnumFrom (psMyInt n (fromIntMyInt (Main.Pos (Main.Succ Main.Zero)))));

numericEnumFromTo n m = takeWhile (flip ltEsMyInt m) (numericEnumFrom n);

otherwise :: MyBool;
otherwise = MyTrue;

primCmpInt :: MyInt  ->  MyInt  ->  Ordering;
primCmpInt (Main.Pos Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Pos Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Pos Main.Zero) = EQ;
primCmpInt (Main.Neg Main.Zero) (Main.Neg Main.Zero) = EQ;
primCmpInt (Main.Pos x) (Main.Pos y) = primCmpNat x y;
primCmpInt (Main.Pos x) (Main.Neg y) = GT;
primCmpInt (Main.Neg x) (Main.Pos y) = LT;
primCmpInt (Main.Neg x) (Main.Neg y) = primCmpNat y x;

primCmpNat :: Main.Nat  ->  Main.Nat  ->  Ordering;
primCmpNat Main.Zero Main.Zero = EQ;
primCmpNat Main.Zero (Main.Succ y) = LT;
primCmpNat (Main.Succ x) Main.Zero = GT;
primCmpNat (Main.Succ x) (Main.Succ y) = primCmpNat x y;

primMinusNat :: Main.Nat  ->  Main.Nat  ->  MyInt;
primMinusNat Main.Zero Main.Zero = Main.Pos Main.Zero;
primMinusNat Main.Zero (Main.Succ y) = Main.Neg (Main.Succ y);
primMinusNat (Main.Succ x) Main.Zero = Main.Pos (Main.Succ x);
primMinusNat (Main.Succ x) (Main.Succ y) = primMinusNat x y;

primPlusInt :: MyInt  ->  MyInt  ->  MyInt;
primPlusInt (Main.Pos x) (Main.Neg y) = primMinusNat x y;
primPlusInt (Main.Neg x) (Main.Pos y) = primMinusNat y x;
primPlusInt (Main.Neg x) (Main.Neg y) = Main.Neg (primPlusNat x y);
primPlusInt (Main.Pos x) (Main.Pos y) = Main.Pos (primPlusNat x y);

primPlusNat :: Main.Nat  ->  Main.Nat  ->  Main.Nat;
primPlusNat Main.Zero Main.Zero = Main.Zero;
primPlusNat Main.Zero (Main.Succ y) = Main.Succ y;
primPlusNat (Main.Succ x) Main.Zero = Main.Succ x;
primPlusNat (Main.Succ x) (Main.Succ y) = Main.Succ (Main.Succ (primPlusNat x y));

psMyInt :: MyInt  ->  MyInt  ->  MyInt;
psMyInt = primPlusInt;

seq :: a  ->  b  ->  b;
seq x y = Main.enforceWHNF (Main.WHNF x) y;

takeWhile :: (a  ->  MyBool)  ->  List a  ->  List a;
takeWhile p Nil = takeWhile3 p Nil;
takeWhile p (Cons x xs) = takeWhile2 p (Cons x xs);

takeWhile0 p x xs MyTrue = Nil;

takeWhile1 p x xs MyTrue = Cons x (takeWhile p xs);
takeWhile1 p x xs MyFalse = takeWhile0 p x xs otherwise;

takeWhile2 p (Cons x xs) = takeWhile1 p x xs (p x);

takeWhile3 p Nil = Nil;
takeWhile3 vx vy = takeWhile2 vx vy;

}

----------------------------------------

(5) Narrow (SOUND)
Haskell To QDPs

digraph dp_graph {
node [outthreshold=100, inthreshold=100];1[label="enumFromToMyInt",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="enumFromToMyInt vz3",fontsize=16,color="grey",shape="box"];3 -> 4[label="",style="dashed", color="grey", weight=3];
4[label="enumFromToMyInt vz3 vz4",fontsize=16,color="black",shape="triangle"];4 -> 5[label="",style="solid", color="black", weight=3];
5[label="numericEnumFromTo vz3 vz4",fontsize=16,color="black",shape="box"];5 -> 6[label="",style="solid", color="black", weight=3];
6[label="takeWhile (flip ltEsMyInt vz4) (numericEnumFrom vz3)",fontsize=16,color="black",shape="triangle"];6 -> 7[label="",style="solid", color="black", weight=3];
7[label="takeWhile (flip ltEsMyInt vz4) (Cons vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];7 -> 8[label="",style="solid", color="black", weight=3];
8[label="takeWhile2 (flip ltEsMyInt vz4) (Cons vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];8 -> 9[label="",style="solid", color="black", weight=3];
9[label="takeWhile1 (flip ltEsMyInt vz4) vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))) (flip ltEsMyInt vz4 vz3)",fontsize=16,color="black",shape="box"];9 -> 10[label="",style="solid", color="black", weight=3];
10[label="takeWhile1 (flip ltEsMyInt vz4) vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))) (ltEsMyInt vz3 vz4)",fontsize=16,color="black",shape="box"];10 -> 11[label="",style="solid", color="black", weight=3];
11[label="takeWhile1 (flip ltEsMyInt vz4) vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))) (fsEsOrdering (compareMyInt vz3 vz4) GT)",fontsize=16,color="black",shape="box"];11 -> 12[label="",style="solid", color="black", weight=3];
12[label="takeWhile1 (flip ltEsMyInt vz4) vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (compareMyInt vz3 vz4) GT))",fontsize=16,color="black",shape="box"];12 -> 13[label="",style="solid", color="black", weight=3];
13[label="takeWhile1 (flip ltEsMyInt vz4) vz3 (dsEm numericEnumFrom (psMyInt vz3 (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt vz3 vz4) GT))",fontsize=16,color="burlywood",shape="box"];810[label="vz3/Pos vz30",fontsize=10,color="white",style="solid",shape="box"];13 -> 810[label="",style="solid", color="burlywood", weight=9];
810 -> 14[label="",style="solid", color="burlywood", weight=3];
811[label="vz3/Neg vz30",fontsize=10,color="white",style="solid",shape="box"];13 -> 811[label="",style="solid", color="burlywood", weight=9];
811 -> 15[label="",style="solid", color="burlywood", weight=3];
14[label="takeWhile1 (flip ltEsMyInt vz4) (Pos vz30) (dsEm numericEnumFrom (psMyInt (Pos vz30) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos vz30) vz4) GT))",fontsize=16,color="burlywood",shape="box"];812[label="vz30/Succ vz300",fontsize=10,color="white",style="solid",shape="box"];14 -> 812[label="",style="solid", color="burlywood", weight=9];
812 -> 16[label="",style="solid", color="burlywood", weight=3];
813[label="vz30/Zero",fontsize=10,color="white",style="solid",shape="box"];14 -> 813[label="",style="solid", color="burlywood", weight=9];
813 -> 17[label="",style="solid", color="burlywood", weight=3];
15[label="takeWhile1 (flip ltEsMyInt vz4) (Neg vz30) (dsEm numericEnumFrom (psMyInt (Neg vz30) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg vz30) vz4) GT))",fontsize=16,color="burlywood",shape="box"];814[label="vz30/Succ vz300",fontsize=10,color="white",style="solid",shape="box"];15 -> 814[label="",style="solid", color="burlywood", weight=9];
814 -> 18[label="",style="solid", color="burlywood", weight=3];
815[label="vz30/Zero",fontsize=10,color="white",style="solid",shape="box"];15 -> 815[label="",style="solid", color="burlywood", weight=9];
815 -> 19[label="",style="solid", color="burlywood", weight=3];
16[label="takeWhile1 (flip ltEsMyInt vz4) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz300)) vz4) GT))",fontsize=16,color="burlywood",shape="box"];816[label="vz4/Pos vz40",fontsize=10,color="white",style="solid",shape="box"];16 -> 816[label="",style="solid", color="burlywood", weight=9];
816 -> 20[label="",style="solid", color="burlywood", weight=3];
817[label="vz4/Neg vz40",fontsize=10,color="white",style="solid",shape="box"];16 -> 817[label="",style="solid", color="burlywood", weight=9];
817 -> 21[label="",style="solid", color="burlywood", weight=3];
17[label="takeWhile1 (flip ltEsMyInt vz4) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) vz4) GT))",fontsize=16,color="burlywood",shape="box"];818[label="vz4/Pos vz40",fontsize=10,color="white",style="solid",shape="box"];17 -> 818[label="",style="solid", color="burlywood", weight=9];
818 -> 22[label="",style="solid", color="burlywood", weight=3];
819[label="vz4/Neg vz40",fontsize=10,color="white",style="solid",shape="box"];17 -> 819[label="",style="solid", color="burlywood", weight=9];
819 -> 23[label="",style="solid", color="burlywood", weight=3];
18[label="takeWhile1 (flip ltEsMyInt vz4) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz300)) vz4) GT))",fontsize=16,color="burlywood",shape="box"];820[label="vz4/Pos vz40",fontsize=10,color="white",style="solid",shape="box"];18 -> 820[label="",style="solid", color="burlywood", weight=9];
820 -> 24[label="",style="solid", color="burlywood", weight=3];
821[label="vz4/Neg vz40",fontsize=10,color="white",style="solid",shape="box"];18 -> 821[label="",style="solid", color="burlywood", weight=9];
821 -> 25[label="",style="solid", color="burlywood", weight=3];
19[label="takeWhile1 (flip ltEsMyInt vz4) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) vz4) GT))",fontsize=16,color="burlywood",shape="box"];822[label="vz4/Pos vz40",fontsize=10,color="white",style="solid",shape="box"];19 -> 822[label="",style="solid", color="burlywood", weight=9];
822 -> 26[label="",style="solid", color="burlywood", weight=3];
823[label="vz4/Neg vz40",fontsize=10,color="white",style="solid",shape="box"];19 -> 823[label="",style="solid", color="burlywood", weight=9];
823 -> 27[label="",style="solid", color="burlywood", weight=3];
20[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz300)) (Pos vz40)) GT))",fontsize=16,color="black",shape="box"];20 -> 28[label="",style="solid", color="black", weight=3];
21[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz300)) (Neg vz40)) GT))",fontsize=16,color="black",shape="box"];21 -> 29[label="",style="solid", color="black", weight=3];
22[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Pos vz40)) GT))",fontsize=16,color="burlywood",shape="box"];824[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];22 -> 824[label="",style="solid", color="burlywood", weight=9];
824 -> 30[label="",style="solid", color="burlywood", weight=3];
825[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];22 -> 825[label="",style="solid", color="burlywood", weight=9];
825 -> 31[label="",style="solid", color="burlywood", weight=3];
23[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Neg vz40)) GT))",fontsize=16,color="burlywood",shape="box"];826[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];23 -> 826[label="",style="solid", color="burlywood", weight=9];
826 -> 32[label="",style="solid", color="burlywood", weight=3];
827[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];23 -> 827[label="",style="solid", color="burlywood", weight=9];
827 -> 33[label="",style="solid", color="burlywood", weight=3];
24[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz300)) (Pos vz40)) GT))",fontsize=16,color="black",shape="box"];24 -> 34[label="",style="solid", color="black", weight=3];
25[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz300)) (Neg vz40)) GT))",fontsize=16,color="black",shape="box"];25 -> 35[label="",style="solid", color="black", weight=3];
26[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Pos vz40)) GT))",fontsize=16,color="burlywood",shape="box"];828[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];26 -> 828[label="",style="solid", color="burlywood", weight=9];
828 -> 36[label="",style="solid", color="burlywood", weight=3];
829[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];26 -> 829[label="",style="solid", color="burlywood", weight=9];
829 -> 37[label="",style="solid", color="burlywood", weight=3];
27[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Neg vz40)) GT))",fontsize=16,color="burlywood",shape="box"];830[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];27 -> 830[label="",style="solid", color="burlywood", weight=9];
830 -> 38[label="",style="solid", color="burlywood", weight=3];
831[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];27 -> 831[label="",style="solid", color="burlywood", weight=9];
831 -> 39[label="",style="solid", color="burlywood", weight=3];
28[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz300) vz40) GT))",fontsize=16,color="burlywood",shape="box"];832[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];28 -> 832[label="",style="solid", color="burlywood", weight=9];
832 -> 40[label="",style="solid", color="burlywood", weight=3];
833[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];28 -> 833[label="",style="solid", color="burlywood", weight=9];
833 -> 41[label="",style="solid", color="burlywood", weight=3];
29[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];29 -> 42[label="",style="solid", color="black", weight=3];
30[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Pos (Succ vz400))) GT))",fontsize=16,color="black",shape="box"];30 -> 43[label="",style="solid", color="black", weight=3];
31[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Pos Zero)) GT))",fontsize=16,color="black",shape="box"];31 -> 44[label="",style="solid", color="black", weight=3];
32[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Neg (Succ vz400))) GT))",fontsize=16,color="black",shape="box"];32 -> 45[label="",style="solid", color="black", weight=3];
33[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Neg Zero)) GT))",fontsize=16,color="black",shape="box"];33 -> 46[label="",style="solid", color="black", weight=3];
34[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];34 -> 47[label="",style="solid", color="black", weight=3];
35[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz40 (Succ vz300)) GT))",fontsize=16,color="burlywood",shape="box"];834[label="vz40/Succ vz400",fontsize=10,color="white",style="solid",shape="box"];35 -> 834[label="",style="solid", color="burlywood", weight=9];
834 -> 48[label="",style="solid", color="burlywood", weight=3];
835[label="vz40/Zero",fontsize=10,color="white",style="solid",shape="box"];35 -> 835[label="",style="solid", color="burlywood", weight=9];
835 -> 49[label="",style="solid", color="burlywood", weight=3];
36[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Pos (Succ vz400))) GT))",fontsize=16,color="black",shape="box"];36 -> 50[label="",style="solid", color="black", weight=3];
37[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Pos Zero)) GT))",fontsize=16,color="black",shape="box"];37 -> 51[label="",style="solid", color="black", weight=3];
38[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Neg (Succ vz400))) GT))",fontsize=16,color="black",shape="box"];38 -> 52[label="",style="solid", color="black", weight=3];
39[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Neg Zero)) GT))",fontsize=16,color="black",shape="box"];39 -> 53[label="",style="solid", color="black", weight=3];
40[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz300) (Succ vz400)) GT))",fontsize=16,color="black",shape="box"];40 -> 54[label="",style="solid", color="black", weight=3];
41[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz300) Zero) GT))",fontsize=16,color="black",shape="box"];41 -> 55[label="",style="solid", color="black", weight=3];
42[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];42 -> 56[label="",style="solid", color="black", weight=3];
43[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz400)) GT))",fontsize=16,color="black",shape="box"];43 -> 57[label="",style="solid", color="black", weight=3];
44[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];44 -> 58[label="",style="solid", color="black", weight=3];
45[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];45 -> 59[label="",style="solid", color="black", weight=3];
46[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];46 -> 60[label="",style="solid", color="black", weight=3];
47[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];47 -> 61[label="",style="solid", color="black", weight=3];
48[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz400) (Succ vz300)) GT))",fontsize=16,color="black",shape="box"];48 -> 62[label="",style="solid", color="black", weight=3];
49[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz300)) GT))",fontsize=16,color="black",shape="box"];49 -> 63[label="",style="solid", color="black", weight=3];
50[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];50 -> 64[label="",style="solid", color="black", weight=3];
51[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];51 -> 65[label="",style="solid", color="black", weight=3];
52[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz400) Zero) GT))",fontsize=16,color="black",shape="box"];52 -> 66[label="",style="solid", color="black", weight=3];
53[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];53 -> 67[label="",style="solid", color="black", weight=3];
54 -> 446[label="",style="dashed", color="red", weight=0];
54[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz300 vz400) GT))",fontsize=16,color="magenta"];54 -> 447[label="",style="dashed", color="magenta", weight=3];
54 -> 448[label="",style="dashed", color="magenta", weight=3];
54 -> 449[label="",style="dashed", color="magenta", weight=3];
54 -> 450[label="",style="dashed", color="magenta", weight=3];
55[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];55 -> 70[label="",style="solid", color="black", weight=3];
56[label="takeWhile1 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];56 -> 71[label="",style="solid", color="black", weight=3];
57[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];57 -> 72[label="",style="solid", color="black", weight=3];
58[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];58 -> 73[label="",style="solid", color="black", weight=3];
59[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];59 -> 74[label="",style="solid", color="black", weight=3];
60[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];60 -> 75[label="",style="solid", color="black", weight=3];
61[label="takeWhile1 (flip ltEsMyInt (Pos vz40)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];61 -> 76[label="",style="solid", color="black", weight=3];
62 -> 722[label="",style="dashed", color="red", weight=0];
62[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz400 vz300) GT))",fontsize=16,color="magenta"];62 -> 723[label="",style="dashed", color="magenta", weight=3];
62 -> 724[label="",style="dashed", color="magenta", weight=3];
62 -> 725[label="",style="dashed", color="magenta", weight=3];
62 -> 726[label="",style="dashed", color="magenta", weight=3];
62 -> 727[label="",style="dashed", color="magenta", weight=3];
63[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];63 -> 79[label="",style="solid", color="black", weight=3];
64[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];64 -> 80[label="",style="solid", color="black", weight=3];
65[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];65 -> 81[label="",style="solid", color="black", weight=3];
66[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];66 -> 82[label="",style="solid", color="black", weight=3];
67[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];67 -> 83[label="",style="solid", color="black", weight=3];
447[label="vz300",fontsize=16,color="green",shape="box"];448[label="vz300",fontsize=16,color="green",shape="box"];449[label="vz400",fontsize=16,color="green",shape="box"];450[label="vz400",fontsize=16,color="green",shape="box"];446[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz24 vz25) GT))",fontsize=16,color="burlywood",shape="triangle"];836[label="vz24/Succ vz240",fontsize=10,color="white",style="solid",shape="box"];446 -> 836[label="",style="solid", color="burlywood", weight=9];
836 -> 475[label="",style="solid", color="burlywood", weight=3];
837[label="vz24/Zero",fontsize=10,color="white",style="solid",shape="box"];446 -> 837[label="",style="solid", color="burlywood", weight=9];
837 -> 476[label="",style="solid", color="burlywood", weight=3];
70[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];70 -> 88[label="",style="solid", color="black", weight=3];
71[label="takeWhile0 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];71 -> 89[label="",style="solid", color="black", weight=3];
72[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];72 -> 90[label="",style="solid", color="black", weight=3];
73[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];73 -> 91[label="",style="solid", color="black", weight=3];
74[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];74 -> 92[label="",style="solid", color="black", weight=3];
75[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];75 -> 93[label="",style="solid", color="black", weight=3];
76[label="Cons (Neg (Succ vz300)) (takeWhile (flip ltEsMyInt (Pos vz40)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];76 -> 94[label="",style="dashed", color="green", weight=3];
723[label="vz300",fontsize=16,color="green",shape="box"];724[label="vz400",fontsize=16,color="green",shape="box"];725 -> 179[label="",style="dashed", color="red", weight=0];
725[label="psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];726[label="vz400",fontsize=16,color="green",shape="box"];727[label="vz300",fontsize=16,color="green",shape="box"];722[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat vz68 vz69) GT))",fontsize=16,color="burlywood",shape="triangle"];838[label="vz68/Succ vz680",fontsize=10,color="white",style="solid",shape="box"];722 -> 838[label="",style="solid", color="burlywood", weight=9];
838 -> 778[label="",style="solid", color="burlywood", weight=3];
839[label="vz68/Zero",fontsize=10,color="white",style="solid",shape="box"];722 -> 839[label="",style="solid", color="burlywood", weight=9];
839 -> 779[label="",style="solid", color="burlywood", weight=3];
79[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];79 -> 99[label="",style="solid", color="black", weight=3];
80[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];80 -> 100[label="",style="solid", color="black", weight=3];
81[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];81 -> 101[label="",style="solid", color="black", weight=3];
82[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];82 -> 102[label="",style="solid", color="black", weight=3];
83[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];83 -> 103[label="",style="solid", color="black", weight=3];
475[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz240) vz25) GT))",fontsize=16,color="burlywood",shape="box"];840[label="vz25/Succ vz250",fontsize=10,color="white",style="solid",shape="box"];475 -> 840[label="",style="solid", color="burlywood", weight=9];
840 -> 482[label="",style="solid", color="burlywood", weight=3];
841[label="vz25/Zero",fontsize=10,color="white",style="solid",shape="box"];475 -> 841[label="",style="solid", color="burlywood", weight=9];
841 -> 483[label="",style="solid", color="burlywood", weight=3];
476[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero vz25) GT))",fontsize=16,color="burlywood",shape="box"];842[label="vz25/Succ vz250",fontsize=10,color="white",style="solid",shape="box"];476 -> 842[label="",style="solid", color="burlywood", weight=9];
842 -> 484[label="",style="solid", color="burlywood", weight=3];
843[label="vz25/Zero",fontsize=10,color="white",style="solid",shape="box"];476 -> 843[label="",style="solid", color="burlywood", weight=9];
843 -> 485[label="",style="solid", color="burlywood", weight=3];
88[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];88 -> 108[label="",style="solid", color="black", weight=3];
89[label="takeWhile0 (flip ltEsMyInt (Neg vz40)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];89 -> 109[label="",style="solid", color="black", weight=3];
90[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];90 -> 110[label="",style="solid", color="black", weight=3];
91[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];91 -> 111[label="",style="dashed", color="green", weight=3];
92[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];92 -> 112[label="",style="solid", color="black", weight=3];
93[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];93 -> 113[label="",style="dashed", color="green", weight=3];
94[label="takeWhile (flip ltEsMyInt (Pos vz40)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];94 -> 114[label="",style="solid", color="black", weight=3];
179[label="psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];179 -> 205[label="",style="solid", color="black", weight=3];
778[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat (Succ vz680) vz69) GT))",fontsize=16,color="burlywood",shape="box"];844[label="vz69/Succ vz690",fontsize=10,color="white",style="solid",shape="box"];778 -> 844[label="",style="solid", color="burlywood", weight=9];
844 -> 781[label="",style="solid", color="burlywood", weight=3];
845[label="vz69/Zero",fontsize=10,color="white",style="solid",shape="box"];778 -> 845[label="",style="solid", color="burlywood", weight=9];
845 -> 782[label="",style="solid", color="burlywood", weight=3];
779[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat Zero vz69) GT))",fontsize=16,color="burlywood",shape="box"];846[label="vz69/Succ vz690",fontsize=10,color="white",style="solid",shape="box"];779 -> 846[label="",style="solid", color="burlywood", weight=9];
846 -> 783[label="",style="solid", color="burlywood", weight=3];
847[label="vz69/Zero",fontsize=10,color="white",style="solid",shape="box"];779 -> 847[label="",style="solid", color="burlywood", weight=9];
847 -> 784[label="",style="solid", color="burlywood", weight=3];
99[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];99 -> 119[label="",style="solid", color="black", weight=3];
100[label="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];100 -> 120[label="",style="dashed", color="green", weight=3];
101[label="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];101 -> 121[label="",style="dashed", color="green", weight=3];
102[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];102 -> 122[label="",style="solid", color="black", weight=3];
103[label="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];103 -> 123[label="",style="dashed", color="green", weight=3];
482[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz240) (Succ vz250)) GT))",fontsize=16,color="black",shape="box"];482 -> 489[label="",style="solid", color="black", weight=3];
483[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz240) Zero) GT))",fontsize=16,color="black",shape="box"];483 -> 490[label="",style="solid", color="black", weight=3];
484[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz250)) GT))",fontsize=16,color="black",shape="box"];484 -> 491[label="",style="solid", color="black", weight=3];
485[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero Zero) GT))",fontsize=16,color="black",shape="box"];485 -> 492[label="",style="solid", color="black", weight=3];
108[label="takeWhile0 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];108 -> 129[label="",style="solid", color="black", weight=3];
109[label="Nil",fontsize=16,color="green",shape="box"];110[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];110 -> 130[label="",style="dashed", color="green", weight=3];
111[label="takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];111 -> 131[label="",style="solid", color="black", weight=3];
112[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz400))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];112 -> 132[label="",style="solid", color="black", weight=3];
113[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];113 -> 133[label="",style="solid", color="black", weight=3];
114[label="takeWhile (flip ltEsMyInt (Pos vz40)) (seq (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];114 -> 134[label="",style="solid", color="black", weight=3];
205[label="primPlusInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];205 -> 244[label="",style="solid", color="black", weight=3];
781[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat (Succ vz680) (Succ vz690)) GT))",fontsize=16,color="black",shape="box"];781 -> 787[label="",style="solid", color="black", weight=3];
782[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat (Succ vz680) Zero) GT))",fontsize=16,color="black",shape="box"];782 -> 788[label="",style="solid", color="black", weight=3];
783[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat Zero (Succ vz690)) GT))",fontsize=16,color="black",shape="box"];783 -> 789[label="",style="solid", color="black", weight=3];
784[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat Zero Zero) GT))",fontsize=16,color="black",shape="box"];784 -> 790[label="",style="solid", color="black", weight=3];
119[label="Cons (Neg (Succ vz300)) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];119 -> 140[label="",style="dashed", color="green", weight=3];
120[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];120 -> 141[label="",style="solid", color="black", weight=3];
121[label="takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];121 -> 142[label="",style="solid", color="black", weight=3];
122[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];122 -> 143[label="",style="solid", color="black", weight=3];
123[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];123 -> 144[label="",style="solid", color="black", weight=3];
489 -> 446[label="",style="dashed", color="red", weight=0];
489[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz240 vz250) GT))",fontsize=16,color="magenta"];489 -> 504[label="",style="dashed", color="magenta", weight=3];
489 -> 505[label="",style="dashed", color="magenta", weight=3];
490[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];490 -> 506[label="",style="solid", color="black", weight=3];
491[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];491 -> 507[label="",style="solid", color="black", weight=3];
492[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];492 -> 508[label="",style="solid", color="black", weight=3];
129[label="takeWhile0 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz300)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];129 -> 152[label="",style="solid", color="black", weight=3];
130[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];130 -> 153[label="",style="solid", color="black", weight=3];
131[label="takeWhile (flip ltEsMyInt (Pos Zero)) (seq (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];131 -> 154[label="",style="solid", color="black", weight=3];
132[label="Nil",fontsize=16,color="green",shape="box"];133[label="takeWhile (flip ltEsMyInt (Neg Zero)) (seq (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];133 -> 155[label="",style="solid", color="black", weight=3];
134[label="takeWhile (flip ltEsMyInt (Pos vz40)) (enforceWHNF (WHNF (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];134 -> 156[label="",style="solid", color="black", weight=3];
244[label="primPlusInt (Neg (Succ vz300)) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];244 -> 272[label="",style="solid", color="black", weight=3];
787 -> 722[label="",style="dashed", color="red", weight=0];
787[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering (primCmpNat vz680 vz690) GT))",fontsize=16,color="magenta"];787 -> 793[label="",style="dashed", color="magenta", weight=3];
787 -> 794[label="",style="dashed", color="magenta", weight=3];
788[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];788 -> 795[label="",style="solid", color="black", weight=3];
789[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];789 -> 796[label="",style="solid", color="black", weight=3];
790[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];790 -> 797[label="",style="solid", color="black", weight=3];
140[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];140 -> 164[label="",style="solid", color="black", weight=3];
141[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (seq (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];141 -> 165[label="",style="solid", color="black", weight=3];
142[label="takeWhile (flip ltEsMyInt (Pos Zero)) (seq (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];142 -> 166[label="",style="solid", color="black", weight=3];
143[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz400))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];143 -> 167[label="",style="solid", color="black", weight=3];
144[label="takeWhile (flip ltEsMyInt (Neg Zero)) (seq (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];144 -> 168[label="",style="solid", color="black", weight=3];
504[label="vz240",fontsize=16,color="green",shape="box"];505[label="vz250",fontsize=16,color="green",shape="box"];506[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];506 -> 520[label="",style="solid", color="black", weight=3];
507[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="triangle"];507 -> 521[label="",style="solid", color="black", weight=3];
508 -> 507[label="",style="dashed", color="red", weight=0];
508[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="magenta"];152[label="Nil",fontsize=16,color="green",shape="box"];153[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (seq (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];153 -> 176[label="",style="solid", color="black", weight=3];
154[label="takeWhile (flip ltEsMyInt (Pos Zero)) (enforceWHNF (WHNF (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];154 -> 177[label="",style="solid", color="black", weight=3];
155 -> 218[label="",style="dashed", color="red", weight=0];
155[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="magenta"];155 -> 219[label="",style="dashed", color="magenta", weight=3];
155 -> 220[label="",style="dashed", color="magenta", weight=3];
156 -> 6[label="",style="dashed", color="red", weight=0];
156[label="takeWhile (flip ltEsMyInt (Pos vz40)) (numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];156 -> 179[label="",style="dashed", color="magenta", weight=3];
156 -> 180[label="",style="dashed", color="magenta", weight=3];
272[label="primMinusNat (Succ Zero) (Succ vz300)",fontsize=16,color="black",shape="box"];272 -> 296[label="",style="solid", color="black", weight=3];
793[label="vz680",fontsize=16,color="green",shape="box"];794[label="vz690",fontsize=16,color="green",shape="box"];795[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not MyTrue)",fontsize=16,color="black",shape="box"];795 -> 798[label="",style="solid", color="black", weight=3];
796[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not MyFalse)",fontsize=16,color="black",shape="triangle"];796 -> 799[label="",style="solid", color="black", weight=3];
797 -> 796[label="",style="dashed", color="red", weight=0];
797[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) (not MyFalse)",fontsize=16,color="magenta"];164[label="takeWhile (flip ltEsMyInt (Neg Zero)) (seq (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];164 -> 188[label="",style="solid", color="black", weight=3];
165[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (enforceWHNF (WHNF (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];165 -> 189[label="",style="solid", color="black", weight=3];
166[label="takeWhile (flip ltEsMyInt (Pos Zero)) (enforceWHNF (WHNF (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];166 -> 190[label="",style="solid", color="black", weight=3];
167[label="Nil",fontsize=16,color="green",shape="box"];168 -> 218[label="",style="dashed", color="red", weight=0];
168[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="magenta"];168 -> 221[label="",style="dashed", color="magenta", weight=3];
168 -> 222[label="",style="dashed", color="magenta", weight=3];
520[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];520 -> 529[label="",style="solid", color="black", weight=3];
521[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];521 -> 530[label="",style="solid", color="black", weight=3];
176[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (enforceWHNF (WHNF (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];176 -> 200[label="",style="solid", color="black", weight=3];
177 -> 6[label="",style="dashed", color="red", weight=0];
177[label="takeWhile (flip ltEsMyInt (Pos Zero)) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];177 -> 201[label="",style="dashed", color="magenta", weight=3];
177 -> 202[label="",style="dashed", color="magenta", weight=3];
219[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];219 -> 225[label="",style="solid", color="black", weight=3];
220 -> 219[label="",style="dashed", color="red", weight=0];
220[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];218[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF vz11) (numericEnumFrom vz10))",fontsize=16,color="black",shape="triangle"];218 -> 226[label="",style="solid", color="black", weight=3];
180[label="Pos vz40",fontsize=16,color="green",shape="box"];296[label="primMinusNat Zero vz300",fontsize=16,color="burlywood",shape="box"];848[label="vz300/Succ vz3000",fontsize=10,color="white",style="solid",shape="box"];296 -> 848[label="",style="solid", color="burlywood", weight=9];
848 -> 321[label="",style="solid", color="burlywood", weight=3];
849[label="vz300/Zero",fontsize=10,color="white",style="solid",shape="box"];296 -> 849[label="",style="solid", color="burlywood", weight=9];
849 -> 322[label="",style="solid", color="burlywood", weight=3];
798[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) MyFalse",fontsize=16,color="black",shape="box"];798 -> 800[label="",style="solid", color="black", weight=3];
799[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) MyTrue",fontsize=16,color="black",shape="box"];799 -> 801[label="",style="solid", color="black", weight=3];
188 -> 218[label="",style="dashed", color="red", weight=0];
188[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="magenta"];188 -> 223[label="",style="dashed", color="magenta", weight=3];
188 -> 224[label="",style="dashed", color="magenta", weight=3];
189 -> 6[label="",style="dashed", color="red", weight=0];
189[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];189 -> 227[label="",style="dashed", color="magenta", weight=3];
189 -> 228[label="",style="dashed", color="magenta", weight=3];
190 -> 6[label="",style="dashed", color="red", weight=0];
190[label="takeWhile (flip ltEsMyInt (Pos Zero)) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];190 -> 229[label="",style="dashed", color="magenta", weight=3];
190 -> 230[label="",style="dashed", color="magenta", weight=3];
221[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];221 -> 231[label="",style="solid", color="black", weight=3];
222 -> 221[label="",style="dashed", color="red", weight=0];
222[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];529[label="takeWhile0 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];529 -> 535[label="",style="solid", color="black", weight=3];
530[label="Cons (Pos (Succ vz23)) (takeWhile (flip ltEsMyInt (Pos (Succ vz22))) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];530 -> 536[label="",style="dashed", color="green", weight=3];
200 -> 6[label="",style="dashed", color="red", weight=0];
200[label="takeWhile (flip ltEsMyInt (Pos (Succ vz400))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];200 -> 242[label="",style="dashed", color="magenta", weight=3];
200 -> 243[label="",style="dashed", color="magenta", weight=3];
201 -> 219[label="",style="dashed", color="red", weight=0];
201[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];202[label="Pos Zero",fontsize=16,color="green",shape="box"];225[label="primPlusInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];225 -> 259[label="",style="solid", color="black", weight=3];
226 -> 6[label="",style="dashed", color="red", weight=0];
226[label="takeWhile (flip ltEsMyInt (Neg Zero)) (numericEnumFrom vz10)",fontsize=16,color="magenta"];226 -> 260[label="",style="dashed", color="magenta", weight=3];
226 -> 261[label="",style="dashed", color="magenta", weight=3];
321[label="primMinusNat Zero (Succ vz3000)",fontsize=16,color="black",shape="box"];321 -> 343[label="",style="solid", color="black", weight=3];
322[label="primMinusNat Zero Zero",fontsize=16,color="black",shape="box"];322 -> 344[label="",style="solid", color="black", weight=3];
800[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) otherwise",fontsize=16,color="black",shape="box"];800 -> 802[label="",style="solid", color="black", weight=3];
801[label="Cons (Neg (Succ vz66)) (takeWhile (flip ltEsMyInt (Neg (Succ vz65))) (dsEm numericEnumFrom vz67))",fontsize=16,color="green",shape="box"];801 -> 803[label="",style="dashed", color="green", weight=3];
223 -> 179[label="",style="dashed", color="red", weight=0];
223[label="psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];224 -> 179[label="",style="dashed", color="red", weight=0];
224[label="psMyInt (Neg (Succ vz300)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];227 -> 221[label="",style="dashed", color="red", weight=0];
227[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];228[label="Pos (Succ vz400)",fontsize=16,color="green",shape="box"];229 -> 221[label="",style="dashed", color="red", weight=0];
229[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];230[label="Pos Zero",fontsize=16,color="green",shape="box"];231[label="primPlusInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];231 -> 262[label="",style="solid", color="black", weight=3];
535[label="takeWhile0 (flip ltEsMyInt (Pos (Succ vz22))) (Pos (Succ vz23)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];535 -> 541[label="",style="solid", color="black", weight=3];
536[label="takeWhile (flip ltEsMyInt (Pos (Succ vz22))) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];536 -> 542[label="",style="solid", color="black", weight=3];
242 -> 219[label="",style="dashed", color="red", weight=0];
242[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];243[label="Pos (Succ vz400)",fontsize=16,color="green",shape="box"];259[label="primPlusInt (Pos Zero) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];259 -> 284[label="",style="solid", color="black", weight=3];
260[label="vz10",fontsize=16,color="green",shape="box"];261[label="Neg Zero",fontsize=16,color="green",shape="box"];343[label="Neg (Succ vz3000)",fontsize=16,color="green",shape="box"];344[label="Pos Zero",fontsize=16,color="green",shape="box"];802[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz65))) (Neg (Succ vz66)) (dsEm numericEnumFrom vz67) MyTrue",fontsize=16,color="black",shape="box"];802 -> 804[label="",style="solid", color="black", weight=3];
803[label="takeWhile (flip ltEsMyInt (Neg (Succ vz65))) (dsEm numericEnumFrom vz67)",fontsize=16,color="black",shape="box"];803 -> 805[label="",style="solid", color="black", weight=3];
262[label="primPlusInt (Neg Zero) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];262 -> 285[label="",style="solid", color="black", weight=3];
541[label="Nil",fontsize=16,color="green",shape="box"];542[label="takeWhile (flip ltEsMyInt (Pos (Succ vz22))) (seq (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];542 -> 546[label="",style="solid", color="black", weight=3];
284[label="Pos (primPlusNat Zero (Succ Zero))",fontsize=16,color="green",shape="box"];284 -> 305[label="",style="dashed", color="green", weight=3];
804[label="Nil",fontsize=16,color="green",shape="box"];805[label="takeWhile (flip ltEsMyInt (Neg (Succ vz65))) (seq vz67 (numericEnumFrom vz67))",fontsize=16,color="black",shape="box"];805 -> 806[label="",style="solid", color="black", weight=3];
285[label="primMinusNat (Succ Zero) Zero",fontsize=16,color="black",shape="box"];285 -> 306[label="",style="solid", color="black", weight=3];
546[label="takeWhile (flip ltEsMyInt (Pos (Succ vz22))) (enforceWHNF (WHNF (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];546 -> 582[label="",style="solid", color="black", weight=3];
305[label="primPlusNat Zero (Succ Zero)",fontsize=16,color="black",shape="box"];305 -> 332[label="",style="solid", color="black", weight=3];
806[label="takeWhile (flip ltEsMyInt (Neg (Succ vz65))) (enforceWHNF (WHNF vz67) (numericEnumFrom vz67))",fontsize=16,color="black",shape="box"];806 -> 807[label="",style="solid", color="black", weight=3];
306[label="Pos (Succ Zero)",fontsize=16,color="green",shape="box"];582 -> 6[label="",style="dashed", color="red", weight=0];
582[label="takeWhile (flip ltEsMyInt (Pos (Succ vz22))) (numericEnumFrom (psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];582 -> 618[label="",style="dashed", color="magenta", weight=3];
582 -> 619[label="",style="dashed", color="magenta", weight=3];
332[label="Succ Zero",fontsize=16,color="green",shape="box"];807 -> 6[label="",style="dashed", color="red", weight=0];
807[label="takeWhile (flip ltEsMyInt (Neg (Succ vz65))) (numericEnumFrom vz67)",fontsize=16,color="magenta"];807 -> 808[label="",style="dashed", color="magenta", weight=3];
807 -> 809[label="",style="dashed", color="magenta", weight=3];
618[label="psMyInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];618 -> 649[label="",style="solid", color="black", weight=3];
619[label="Pos (Succ vz22)",fontsize=16,color="green",shape="box"];808[label="vz67",fontsize=16,color="green",shape="box"];809[label="Neg (Succ vz65)",fontsize=16,color="green",shape="box"];649[label="primPlusInt (Pos (Succ vz23)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];649 -> 662[label="",style="solid", color="black", weight=3];
662[label="primPlusInt (Pos (Succ vz23)) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];662 -> 700[label="",style="solid", color="black", weight=3];
700[label="Pos (primPlusNat (Succ vz23) (Succ Zero))",fontsize=16,color="green",shape="box"];700 -> 712[label="",style="dashed", color="green", weight=3];
712[label="primPlusNat (Succ vz23) (Succ Zero)",fontsize=16,color="black",shape="box"];712 -> 721[label="",style="solid", color="black", weight=3];
721[label="Succ (Succ (primPlusNat vz23 Zero))",fontsize=16,color="green",shape="box"];721 -> 780[label="",style="dashed", color="green", weight=3];
780[label="primPlusNat vz23 Zero",fontsize=16,color="burlywood",shape="box"];850[label="vz23/Succ vz230",fontsize=10,color="white",style="solid",shape="box"];780 -> 850[label="",style="solid", color="burlywood", weight=9];
850 -> 785[label="",style="solid", color="burlywood", weight=3];
851[label="vz23/Zero",fontsize=10,color="white",style="solid",shape="box"];780 -> 851[label="",style="solid", color="burlywood", weight=9];
851 -> 786[label="",style="solid", color="burlywood", weight=3];
785[label="primPlusNat (Succ vz230) Zero",fontsize=16,color="black",shape="box"];785 -> 791[label="",style="solid", color="black", weight=3];
786[label="primPlusNat Zero Zero",fontsize=16,color="black",shape="box"];786 -> 792[label="",style="solid", color="black", weight=3];
791[label="Succ vz230",fontsize=16,color="green",shape="box"];792[label="Zero",fontsize=16,color="green",shape="box"];}

----------------------------------------

(6)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile12(vz65, vz66, vz67) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67)
   new_takeWhile(Main.Pos(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Zero), new_psMyInt)
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> new_takeWhile1(vz400, vz300, vz300, vz400)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(new_psMyInt, new_psMyInt)
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Neg(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Succ(vz400)), new_psMyInt1)
   new_takeWhile1(vz22, vz23, Main.Succ(vz240), Main.Succ(vz250)) -> new_takeWhile1(vz22, vz23, vz240, vz250)
   new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Succ(vz690)) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Pos(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Zero), new_psMyInt1)
   new_takeWhile11(vz65, vz66, vz67, Main.Succ(vz680), Main.Succ(vz690)) -> new_takeWhile11(vz65, vz66, vz67, vz680, vz690)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Succ(vz400)), new_psMyInt)
   new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Zero) -> new_takeWhile12(vz65, vz66, vz67)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Neg(Main.Succ(vz400)), Main.Neg(Main.Succ(vz300))) -> new_takeWhile11(vz400, vz300, new_psMyInt0(vz300), vz400, vz300)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Pos(vz40), Main.Neg(Main.Succ(vz300))) -> new_takeWhile(Main.Pos(vz40), new_psMyInt0(vz300))
   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(7) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 4 less nodes.
----------------------------------------

(8)
Complex Obligation (AND)

----------------------------------------

(9)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(new_psMyInt, new_psMyInt)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(10) MRRProof (EQUIVALENT)
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.


Strictly oriented rules of the TRS R:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)

Used ordering: Polynomial interpretation [POLO]:

   POL(Main.Neg(x_1)) = x_1
   POL(Main.Pos(x_1)) = x_1
   POL(Main.Succ(x_1)) = 2*x_1
   POL(Main.Zero) = 0
   POL(new_primPlusNat(x_1)) = 2 + 2*x_1
   POL(new_psMyInt) = 0
   POL(new_psMyInt0(x_1)) = x_1
   POL(new_psMyInt1) = 0
   POL(new_takeWhile(x_1, x_2)) = 2 + x_1 + x_2
   POL(new_takeWhile0(x_1, x_2)) = 2 + x_1 + x_2


----------------------------------------

(11)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(new_psMyInt, new_psMyInt)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(12) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(new_psMyInt, new_psMyInt) at position [0] we obtained the following new rules [LPAR04]:

   (new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt),new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt))


----------------------------------------

(13)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(14) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))


----------------------------------------

(15)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(16) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1) at position [0] we obtained the following new rules [LPAR04]:

   (new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1),new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1))


----------------------------------------

(17)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(18) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt) at position [1] we obtained the following new rules [LPAR04]:

   (new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))),new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))))


----------------------------------------

(19)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(20) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(21)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(22) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   new_psMyInt


----------------------------------------

(23)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(24) TransformationProof (EQUIVALENT)
By rewriting [LPAR04] the rule new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), new_psMyInt1) at position [1] we obtained the following new rules [LPAR04]:

   (new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))),new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))))


----------------------------------------

(25)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(26) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(27)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(28) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   new_psMyInt1


----------------------------------------

(29)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(30) QDPOrderProof (EQUIVALENT)
We use the reduction pair processor [LPAR04,JAR06].


The following pairs can be oriented strictly and are deleted.

   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz300))) -> new_takeWhile0(new_psMyInt0(vz300), new_psMyInt0(vz300))
The remaining pairs can at least be oriented weakly.
Used ordering:  Polynomial interpretation [POLO]:

   POL(Main.Neg(x_1)) = x_1
   POL(Main.Pos(x_1)) = 0
   POL(Main.Succ(x_1)) = 1 + x_1
   POL(Main.Zero) = 0
   POL(new_psMyInt0(x_1)) = x_1
   POL(new_takeWhile(x_1, x_2)) = x_2
   POL(new_takeWhile0(x_1, x_2)) = x_2

The following usable rules [FROCOS05] with respect to the argument filtering of the ordering [JAR06] were oriented:

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))


----------------------------------------

(31)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(32) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule new_takeWhile0(vz11, vz10) -> new_takeWhile(Main.Neg(Main.Zero), vz10) we obtained the following new rules [LPAR04]:

   (new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))) -> new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Succ(Main.Zero))),new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))) -> new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Succ(Main.Zero))))


----------------------------------------

(33)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero)))
   new_takeWhile0(Main.Pos(Main.Succ(Main.Zero)), Main.Pos(Main.Succ(Main.Zero))) -> new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Succ(Main.Zero)))

The TRS R consists of the following rules:

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

The set Q consists of the following terms:

   new_psMyInt0(Main.Zero)
   new_psMyInt0(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(34) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.
----------------------------------------

(35)
TRUE

----------------------------------------

(36)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile1(vz22, vz23, Main.Succ(vz240), Main.Succ(vz250)) -> new_takeWhile1(vz22, vz23, vz240, vz250)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> new_takeWhile1(vz400, vz300, vz300, vz400)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(37) QDPPairToRuleProof (EQUIVALENT)
The dependency pair new_takeWhile1(vz22, vz23, Main.Succ(vz240), Main.Succ(vz250)) -> new_takeWhile1(vz22, vz23, vz240, vz250) was transformed to the following new rules:
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

the following new pairs maintain the fan-in:
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))

the following new pairs maintain the fan-out:
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)

----------------------------------------

(38)
Complex Obligation (AND)

----------------------------------------

(39)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> new_takeWhile1(vz400, vz300, vz300, vz400)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(40) TransformationProof (EQUIVALENT)
By instantiating [LPAR04] the rule new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> new_takeWhile1(vz400, vz300, vz300, vz400) we obtained the following new rules [LPAR04]:

   (new_takeWhile(Main.Pos(Main.Succ(z0)), Main.Pos(Main.Succ(Main.Succ(y_0)))) -> new_takeWhile1(z0, Main.Succ(y_0), Main.Succ(y_0), z0),new_takeWhile(Main.Pos(Main.Succ(z0)), Main.Pos(Main.Succ(Main.Succ(y_0)))) -> new_takeWhile1(z0, Main.Succ(y_0), Main.Succ(y_0), z0))


----------------------------------------

(41)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile(Main.Pos(Main.Succ(z0)), Main.Pos(Main.Succ(Main.Succ(y_0)))) -> new_takeWhile1(z0, Main.Succ(y_0), Main.Succ(y_0), z0)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(42) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
----------------------------------------

(43)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(44) UsableRulesProof (EQUIVALENT)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
----------------------------------------

(45)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(46) QReductionProof (EQUIVALENT)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))


----------------------------------------

(47)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(48) InductionCalculusProof (EQUIVALENT)
Note that final constraints are written in bold face.



For Pair new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400)) the following chains were created:
*We consider the chain new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3))) -> H(x2, x3, anew_new_takeWhile1(x3, x2)), H(x4, x5, cons_new_takeWhile1(Main.Zero, Main.Succ(x6))) -> new_takeWhile1(x4, x5, Main.Zero, Main.Succ(x6)) which results in the following constraint:

(1)    (H(x2, x3, anew_new_takeWhile1(x3, x2))=H(x4, x5, cons_new_takeWhile1(Main.Zero, Main.Succ(x6)))  ==>  new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3)))_>=_H(x2, x3, anew_new_takeWhile1(x3, x2)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (anew_new_takeWhile1(x3, x2)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3)))_>=_H(x2, x3, anew_new_takeWhile1(x3, x2)))



We simplified constraint (2) using rule (V) (with possible (I) afterwards) using induction on anew_new_takeWhile1(x3, x2)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) which results in the following new constraint:

(3)    (new_new_takeWhile1(x101, x100)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x100))), Main.Pos(Main.Succ(Main.Succ(x101))))_>=_H(Main.Succ(x100), Main.Succ(x101), anew_new_takeWhile1(Main.Succ(x101), Main.Succ(x100))))



We simplified constraint (3) using rule (V) (with possible (I) afterwards) using induction on new_new_takeWhile1(x101, x100)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) which results in the following new constraints:

(4)    (new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) & (\/x104:new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x104))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102))))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))

(5)    (cons_new_takeWhile1(Main.Zero, Main.Succ(x105))=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))

(6)    (cons_new_takeWhile1(Main.Zero, Main.Zero)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))



We simplified constraint (4) using rule (VI) where we applied the induction hypothesis (\/x104:new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x104))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))) with sigma = [x104 / x6] which results in the following new constraint:

(7)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))



We simplified constraint (5) using rules (I), (II), (IV) which results in the following new constraint:

(8)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))



We solved constraint (6) using rules (I), (II).
*We consider the chain new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10))) -> H(x9, x10, anew_new_takeWhile1(x10, x9)), H(x11, x12, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(x11, x12, Main.Zero, Main.Zero) which results in the following constraint:

(1)    (H(x9, x10, anew_new_takeWhile1(x10, x9))=H(x11, x12, cons_new_takeWhile1(Main.Zero, Main.Zero))  ==>  new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10)))_>=_H(x9, x10, anew_new_takeWhile1(x10, x9)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (anew_new_takeWhile1(x10, x9)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10)))_>=_H(x9, x10, anew_new_takeWhile1(x10, x9)))



We simplified constraint (2) using rule (V) (with possible (I) afterwards) using induction on anew_new_takeWhile1(x10, x9)=cons_new_takeWhile1(Main.Zero, Main.Zero) which results in the following new constraint:

(3)    (new_new_takeWhile1(x107, x106)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x106))), Main.Pos(Main.Succ(Main.Succ(x107))))_>=_H(Main.Succ(x106), Main.Succ(x107), anew_new_takeWhile1(Main.Succ(x107), Main.Succ(x106))))



We simplified constraint (3) using rule (V) (with possible (I) afterwards) using induction on new_new_takeWhile1(x107, x106)=cons_new_takeWhile1(Main.Zero, Main.Zero) which results in the following new constraints:

(4)    (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero) & (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108))))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))

(5)    (cons_new_takeWhile1(Main.Zero, Main.Succ(x110))=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x110)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x110)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x110)))))

(6)    (cons_new_takeWhile1(Main.Zero, Main.Zero)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))



We simplified constraint (4) using rule (VI) where we applied the induction hypothesis (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))) with sigma = [ ] which results in the following new constraint:

(7)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))



We solved constraint (5) using rules (I), (II).We simplified constraint (6) using rules (I), (II) which results in the following new constraint:

(8)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))








For Pair H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) the following chains were created:
*We consider the chain H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25))) -> new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)), new_takeWhile1(x26, x27, Main.Zero, Main.Succ(x28)) -> new_takeWhile(Main.Pos(Main.Succ(x26)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x27))))) which results in the following constraint:

(1)    (new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25))=new_takeWhile1(x26, x27, Main.Zero, Main.Succ(x28))  ==>  H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))








For Pair new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23))))) the following chains were created:
*We consider the chain new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40)) -> new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))), new_takeWhile(Main.Pos(Main.Succ(x41)), Main.Pos(Main.Succ(x42))) -> H(x41, x42, anew_new_takeWhile1(x42, x41)) which results in the following constraint:

(1)    (new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39)))))=new_takeWhile(Main.Pos(Main.Succ(x41)), Main.Pos(Main.Succ(x42)))  ==>  new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))








For Pair H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) the following chains were created:
*We consider the chain H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(x66, x67, Main.Zero, Main.Zero), new_takeWhile1(x68, x69, Main.Zero, Main.Zero) -> new_takeWhile10(x68, x69) which results in the following constraint:

(1)    (new_takeWhile1(x66, x67, Main.Zero, Main.Zero)=new_takeWhile1(x68, x69, Main.Zero, Main.Zero)  ==>  H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))








For Pair new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23) the following chains were created:
*We consider the chain new_takeWhile1(x82, x83, Main.Zero, Main.Zero) -> new_takeWhile10(x82, x83), new_takeWhile10(x84, x85) -> new_takeWhile(Main.Pos(Main.Succ(x84)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x85))))) which results in the following constraint:

(1)    (new_takeWhile10(x82, x83)=new_takeWhile10(x84, x85)  ==>  new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))








For Pair new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23))))) the following chains were created:
*We consider the chain new_takeWhile10(x86, x87) -> new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))), new_takeWhile(Main.Pos(Main.Succ(x88)), Main.Pos(Main.Succ(x89))) -> H(x88, x89, anew_new_takeWhile1(x89, x88)) which results in the following constraint:

(1)    (new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87)))))=new_takeWhile(Main.Pos(Main.Succ(x88)), Main.Pos(Main.Succ(x89)))  ==>  new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))








To summarize, we get the following constraints P__>=_ for the following pairs.

*new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))

*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))




*H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))

*(H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))




*new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

*(new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))




*H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)

*(H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))




*new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)

*(new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))




*new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

*(new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))








The constraints for P_> respective P_bound are constructed from P__>=_ where we just replace every occurence of "t _>=_ s" in P__>=_ by  "t > s" respective "t _>=_ c". Here c stands for the fresh constant used for P_bound. 
----------------------------------------

(49)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(50) NonInfProof (EQUIVALENT)
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:

Note that final constraints are written in bold face.



For Pair new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400)) the following chains were created:
*We consider the chain new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3))) -> H(x2, x3, anew_new_takeWhile1(x3, x2)), H(x4, x5, cons_new_takeWhile1(Main.Zero, Main.Succ(x6))) -> new_takeWhile1(x4, x5, Main.Zero, Main.Succ(x6)) which results in the following constraint:

(1)    (H(x2, x3, anew_new_takeWhile1(x3, x2))=H(x4, x5, cons_new_takeWhile1(Main.Zero, Main.Succ(x6)))  ==>  new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3)))_>=_H(x2, x3, anew_new_takeWhile1(x3, x2)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (anew_new_takeWhile1(x3, x2)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(x2)), Main.Pos(Main.Succ(x3)))_>=_H(x2, x3, anew_new_takeWhile1(x3, x2)))



We simplified constraint (2) using rule (V) (with possible (I) afterwards) using induction on anew_new_takeWhile1(x3, x2)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) which results in the following new constraint:

(3)    (new_new_takeWhile1(x101, x100)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x100))), Main.Pos(Main.Succ(Main.Succ(x101))))_>=_H(Main.Succ(x100), Main.Succ(x101), anew_new_takeWhile1(Main.Succ(x101), Main.Succ(x100))))



We simplified constraint (3) using rule (V) (with possible (I) afterwards) using induction on new_new_takeWhile1(x101, x100)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) which results in the following new constraints:

(4)    (new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6)) & (\/x104:new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x104))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102))))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))

(5)    (cons_new_takeWhile1(Main.Zero, Main.Succ(x105))=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))

(6)    (cons_new_takeWhile1(Main.Zero, Main.Zero)=cons_new_takeWhile1(Main.Zero, Main.Succ(x6))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))



We simplified constraint (4) using rule (VI) where we applied the induction hypothesis (\/x104:new_new_takeWhile1(x103, x102)=cons_new_takeWhile1(Main.Zero, Main.Succ(x104))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))) with sigma = [x104 / x6] which results in the following new constraint:

(7)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))



We simplified constraint (5) using rules (I), (II), (IV) which results in the following new constraint:

(8)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))



We solved constraint (6) using rules (I), (II).
*We consider the chain new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10))) -> H(x9, x10, anew_new_takeWhile1(x10, x9)), H(x11, x12, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(x11, x12, Main.Zero, Main.Zero) which results in the following constraint:

(1)    (H(x9, x10, anew_new_takeWhile1(x10, x9))=H(x11, x12, cons_new_takeWhile1(Main.Zero, Main.Zero))  ==>  new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10)))_>=_H(x9, x10, anew_new_takeWhile1(x10, x9)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (anew_new_takeWhile1(x10, x9)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(x9)), Main.Pos(Main.Succ(x10)))_>=_H(x9, x10, anew_new_takeWhile1(x10, x9)))



We simplified constraint (2) using rule (V) (with possible (I) afterwards) using induction on anew_new_takeWhile1(x10, x9)=cons_new_takeWhile1(Main.Zero, Main.Zero) which results in the following new constraint:

(3)    (new_new_takeWhile1(x107, x106)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x106))), Main.Pos(Main.Succ(Main.Succ(x107))))_>=_H(Main.Succ(x106), Main.Succ(x107), anew_new_takeWhile1(Main.Succ(x107), Main.Succ(x106))))



We simplified constraint (3) using rule (V) (with possible (I) afterwards) using induction on new_new_takeWhile1(x107, x106)=cons_new_takeWhile1(Main.Zero, Main.Zero) which results in the following new constraints:

(4)    (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero) & (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108))))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))

(5)    (cons_new_takeWhile1(Main.Zero, Main.Succ(x110))=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x110)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x110)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x110)))))

(6)    (cons_new_takeWhile1(Main.Zero, Main.Zero)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))



We simplified constraint (4) using rule (VI) where we applied the induction hypothesis (new_new_takeWhile1(x109, x108)=cons_new_takeWhile1(Main.Zero, Main.Zero)  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))) with sigma = [ ] which results in the following new constraint:

(7)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))



We solved constraint (5) using rules (I), (II).We simplified constraint (6) using rules (I), (II) which results in the following new constraint:

(8)    (new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))








For Pair H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) the following chains were created:
*We consider the chain H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25))) -> new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)), new_takeWhile1(x26, x27, Main.Zero, Main.Succ(x28)) -> new_takeWhile(Main.Pos(Main.Succ(x26)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x27))))) which results in the following constraint:

(1)    (new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25))=new_takeWhile1(x26, x27, Main.Zero, Main.Succ(x28))  ==>  H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))








For Pair new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23))))) the following chains were created:
*We consider the chain new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40)) -> new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))), new_takeWhile(Main.Pos(Main.Succ(x41)), Main.Pos(Main.Succ(x42))) -> H(x41, x42, anew_new_takeWhile1(x42, x41)) which results in the following constraint:

(1)    (new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39)))))=new_takeWhile(Main.Pos(Main.Succ(x41)), Main.Pos(Main.Succ(x42)))  ==>  new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))








For Pair H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) the following chains were created:
*We consider the chain H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(x66, x67, Main.Zero, Main.Zero), new_takeWhile1(x68, x69, Main.Zero, Main.Zero) -> new_takeWhile10(x68, x69) which results in the following constraint:

(1)    (new_takeWhile1(x66, x67, Main.Zero, Main.Zero)=new_takeWhile1(x68, x69, Main.Zero, Main.Zero)  ==>  H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))








For Pair new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23) the following chains were created:
*We consider the chain new_takeWhile1(x82, x83, Main.Zero, Main.Zero) -> new_takeWhile10(x82, x83), new_takeWhile10(x84, x85) -> new_takeWhile(Main.Pos(Main.Succ(x84)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x85))))) which results in the following constraint:

(1)    (new_takeWhile10(x82, x83)=new_takeWhile10(x84, x85)  ==>  new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))








For Pair new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23))))) the following chains were created:
*We consider the chain new_takeWhile10(x86, x87) -> new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))), new_takeWhile(Main.Pos(Main.Succ(x88)), Main.Pos(Main.Succ(x89))) -> H(x88, x89, anew_new_takeWhile1(x89, x88)) which results in the following constraint:

(1)    (new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87)))))=new_takeWhile(Main.Pos(Main.Succ(x88)), Main.Pos(Main.Succ(x89)))  ==>  new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))



We simplified constraint (1) using rules (I), (II), (IV) which results in the following new constraint:

(2)    (new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))








To summarize, we get the following constraints P__>=_ for the following pairs.

*new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))

*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x102))), Main.Pos(Main.Succ(Main.Succ(x103))))_>=_H(Main.Succ(x102), Main.Succ(x103), anew_new_takeWhile1(Main.Succ(x103), Main.Succ(x102)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x102)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x103)))))_>=_H(Main.Succ(Main.Succ(x102)), Main.Succ(Main.Succ(x103)), anew_new_takeWhile1(Main.Succ(Main.Succ(x103)), Main.Succ(Main.Succ(x102)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x105)))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Succ(x105)), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Succ(x105)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(x108))), Main.Pos(Main.Succ(Main.Succ(x109))))_>=_H(Main.Succ(x108), Main.Succ(x109), anew_new_takeWhile1(Main.Succ(x109), Main.Succ(x108)))  ==>  new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Succ(x108)))), Main.Pos(Main.Succ(Main.Succ(Main.Succ(x109)))))_>=_H(Main.Succ(Main.Succ(x108)), Main.Succ(Main.Succ(x109)), anew_new_takeWhile1(Main.Succ(Main.Succ(x109)), Main.Succ(Main.Succ(x108)))))


*(new_takeWhile(Main.Pos(Main.Succ(Main.Succ(Main.Zero))), Main.Pos(Main.Succ(Main.Succ(Main.Zero))))_>=_H(Main.Succ(Main.Zero), Main.Succ(Main.Zero), anew_new_takeWhile1(Main.Succ(Main.Zero), Main.Succ(Main.Zero))))




*H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))

*(H(x23, x24, cons_new_takeWhile1(Main.Zero, Main.Succ(x25)))_>=_new_takeWhile1(x23, x24, Main.Zero, Main.Succ(x25)))




*new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

*(new_takeWhile1(x38, x39, Main.Zero, Main.Succ(x40))_>=_new_takeWhile(Main.Pos(Main.Succ(x38)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x39))))))




*H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)

*(H(x66, x67, cons_new_takeWhile1(Main.Zero, Main.Zero))_>=_new_takeWhile1(x66, x67, Main.Zero, Main.Zero))




*new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)

*(new_takeWhile1(x82, x83, Main.Zero, Main.Zero)_>=_new_takeWhile10(x82, x83))




*new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

*(new_takeWhile10(x86, x87)_>=_new_takeWhile(Main.Pos(Main.Succ(x86)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(x87))))))








The constraints for P_> respective P_bound are constructed from P__>=_ where we just replace every occurence of "t _>=_ s" in P__>=_ by  "t > s" respective "t _>=_ c". Here c stands for the fresh constant used for P_bound. 

Using the following integer polynomial ordering the  resulting constraints can be solved 

Polynomial interpretation [NONINF]:

   POL(H(x_1, x_2, x_3)) = -1 + x_1 - x_2 - x_3
   POL(Main.Pos(x_1)) = 1 + x_1
   POL(Main.Succ(x_1)) = 1 + x_1
   POL(Main.Zero) = 0
   POL(anew_new_takeWhile1(x_1, x_2)) = 0
   POL(c) = -1
   POL(cons_new_takeWhile1(x_1, x_2)) = 0
   POL(new_new_takeWhile1(x_1, x_2)) = 0
   POL(new_primPlusNat(x_1)) = x_1
   POL(new_takeWhile(x_1, x_2)) = x_1 - x_2
   POL(new_takeWhile1(x_1, x_2, x_3, x_4)) = -1 + x_1 - x_2 + x_3
   POL(new_takeWhile10(x_1, x_2)) = -1 + x_1 - x_2


The following pairs  are in P_>:
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
The following pairs are in P_bound:
   new_takeWhile(Main.Pos(Main.Succ(vz400)), Main.Pos(Main.Succ(vz300))) -> H(vz400, vz300, anew_new_takeWhile1(vz300, vz400))
The following rules are usable:
   new_new_takeWhile1(vz240, vz250) -> anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250))
   Main.Zero -> new_primPlusNat(Main.Zero)
   Main.Succ(vz230) -> new_primPlusNat(Main.Succ(vz230))
   new_new_takeWhile1(vz240, vz250) -> new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250))
   cons_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> new_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   cons_new_takeWhile1(Main.Zero, Main.Zero) -> new_new_takeWhile1(Main.Zero, Main.Zero)

----------------------------------------

(51)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250))
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Succ(vz250)) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))
   H(vz22, vz23, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero)
   new_takeWhile1(vz22, vz23, Main.Zero, Main.Zero) -> new_takeWhile10(vz22, vz23)
   new_takeWhile10(vz22, vz23) -> new_takeWhile(Main.Pos(Main.Succ(vz22)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz23)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   anew_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Succ(vz240), Main.Succ(vz250)) -> new_new_takeWhile1(vz240, vz250)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz250)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz250))
   new_new_takeWhile1(Main.Zero, Main.Zero) -> cons_new_takeWhile1(Main.Zero, Main.Zero)

The set Q consists of the following terms:

   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))
   new_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   anew_new_takeWhile1(Main.Succ(x0), Main.Succ(x1))
   new_new_takeWhile1(Main.Zero, Main.Succ(x0))
   new_new_takeWhile1(Main.Zero, Main.Zero)

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(52) DependencyGraphProof (EQUIVALENT)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 5 less nodes.
----------------------------------------

(53)
TRUE

----------------------------------------

(54)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile1(vz22, vz23, Main.Succ(vz240), Main.Succ(vz250)) -> new_takeWhile1(vz22, vz23, vz240, vz250)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(55) QDPSizeChangeProof (EQUIVALENT)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem. 

From the DPs we obtained the following set of size-change graphs:
*new_takeWhile1(vz22, vz23, Main.Succ(vz240), Main.Succ(vz250)) -> new_takeWhile1(vz22, vz23, vz240, vz250)
The graph contains the following edges 1 >= 1, 2 >= 2, 3 > 3, 4 > 4


----------------------------------------

(56)
YES

----------------------------------------

(57)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Pos(vz40), Main.Neg(Main.Succ(vz300))) -> new_takeWhile(Main.Pos(vz40), new_psMyInt0(vz300))

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(58) QDPSizeChangeProof (EQUIVALENT)
We used the following order together with the size-change analysis [AAECC05] to show that there are no infinite chains for this DP problem. 

Order:Polynomial interpretation [POLO]:

   POL(Main.Neg(x_1)) = x_1
   POL(Main.Pos(x_1)) = 1
   POL(Main.Succ(x_1)) = 1 + x_1
   POL(Main.Zero) = 1
   POL(new_psMyInt0(x_1)) = x_1




From the DPs we obtained the following set of size-change graphs:
*new_takeWhile(Main.Pos(vz40), Main.Neg(Main.Succ(vz300))) -> new_takeWhile(Main.Pos(vz40), new_psMyInt0(vz300)) (allowed arguments on rhs = {1, 2})
The graph contains the following edges 1 >= 1, 2 > 2



We oriented the following set of usable rules [AAECC05,FROCOS05].

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

----------------------------------------

(59)
YES

----------------------------------------

(60)
Obligation:
Q DP problem:
The TRS P consists of the following rules:

   new_takeWhile(Main.Neg(Main.Succ(vz400)), Main.Neg(Main.Succ(vz300))) -> new_takeWhile11(vz400, vz300, new_psMyInt0(vz300), vz400, vz300)
   new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Succ(vz690)) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67)
   new_takeWhile11(vz65, vz66, vz67, Main.Succ(vz680), Main.Succ(vz690)) -> new_takeWhile11(vz65, vz66, vz67, vz680, vz690)
   new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Zero) -> new_takeWhile12(vz65, vz66, vz67)
   new_takeWhile12(vz65, vz66, vz67) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67)

The TRS R consists of the following rules:

   new_psMyInt1 -> Main.Pos(Main.Succ(Main.Zero))
   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz230)) -> Main.Succ(vz230)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

   new_psMyInt1
   new_psMyInt0(Main.Zero)
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   new_primPlusNat(Main.Succ(x0))

We have to consider all minimal (P,Q,R)-chains.
----------------------------------------

(61) QDPSizeChangeProof (EQUIVALENT)
We used the following order together with the size-change analysis [AAECC05] to show that there are no infinite chains for this DP problem. 

Order:Polynomial interpretation [POLO]:

   POL(Main.Neg(x_1)) = x_1
   POL(Main.Pos(x_1)) = 0
   POL(Main.Succ(x_1)) = 1 + x_1
   POL(Main.Zero) = 1
   POL(new_psMyInt0(x_1)) = x_1




From the DPs we obtained the following set of size-change graphs:
*new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Succ(vz690)) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67) (allowed arguments on rhs = {1, 2})
The graph contains the following edges 3 >= 2


*new_takeWhile12(vz65, vz66, vz67) -> new_takeWhile(Main.Neg(Main.Succ(vz65)), vz67) (allowed arguments on rhs = {1, 2})
The graph contains the following edges 3 >= 2


*new_takeWhile(Main.Neg(Main.Succ(vz400)), Main.Neg(Main.Succ(vz300))) -> new_takeWhile11(vz400, vz300, new_psMyInt0(vz300), vz400, vz300) (allowed arguments on rhs = {1, 2, 3, 4, 5})
The graph contains the following edges 1 > 1, 2 > 2, 2 > 3, 1 > 4, 2 > 5


*new_takeWhile11(vz65, vz66, vz67, Main.Succ(vz680), Main.Succ(vz690)) -> new_takeWhile11(vz65, vz66, vz67, vz680, vz690) (allowed arguments on rhs = {1, 2, 3, 4, 5})
The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3, 4 > 4, 5 > 5


*new_takeWhile11(vz65, vz66, vz67, Main.Zero, Main.Zero) -> new_takeWhile12(vz65, vz66, vz67) (allowed arguments on rhs = {1, 2, 3})
The graph contains the following edges 1 >= 1, 2 >= 2, 3 >= 3



We oriented the following set of usable rules [AAECC05,FROCOS05].

   new_psMyInt0(Main.Zero) -> Main.Pos(Main.Zero)
   new_psMyInt0(Main.Succ(vz3000)) -> Main.Neg(Main.Succ(vz3000))

----------------------------------------

(62)
YES