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


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


YES
proof of /export/starexec/sandbox2/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, 98 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, 32 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, 193 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 Tup2 a b = Tup2 a b ;

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 a  ->  b  ->  b;
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 :: (b  ->  c  ->  a)  ->  c  ->  b  ->  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;

rangeMyInt :: Tup2 MyInt MyInt  ->  List MyInt;
rangeMyInt (Tup2 m n) = enumFromToMyInt m n;

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 Tup2 b a = Tup2 b a ;

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 :: (b  ->  c  ->  a)  ->  c  ->  b  ->  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;

rangeMyInt :: Tup2 MyInt MyInt  ->  List MyInt;
rangeMyInt (Tup2 m n) = enumFromToMyInt m n;

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 Tup2 b a = Tup2 b a ;

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 :: (b  ->  a  ->  c)  ->  a  ->  b  ->  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;

rangeMyInt :: Tup2 MyInt MyInt  ->  List MyInt;
rangeMyInt (Tup2 m n) = enumFromToMyInt m n;

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="rangeMyInt",fontsize=16,color="grey",shape="box"];1 -> 3[label="",style="dashed", color="grey", weight=3];
3[label="rangeMyInt vz3",fontsize=16,color="burlywood",shape="triangle"];811[label="vz3/Tup2 vz30 vz31",fontsize=10,color="white",style="solid",shape="box"];3 -> 811[label="",style="solid", color="burlywood", weight=9];
811 -> 4[label="",style="solid", color="burlywood", weight=3];
4[label="rangeMyInt (Tup2 vz30 vz31)",fontsize=16,color="black",shape="box"];4 -> 5[label="",style="solid", color="black", weight=3];
5[label="enumFromToMyInt vz30 vz31",fontsize=16,color="black",shape="box"];5 -> 6[label="",style="solid", color="black", weight=3];
6[label="numericEnumFromTo vz30 vz31",fontsize=16,color="black",shape="box"];6 -> 7[label="",style="solid", color="black", weight=3];
7[label="takeWhile (flip ltEsMyInt vz31) (numericEnumFrom vz30)",fontsize=16,color="black",shape="triangle"];7 -> 8[label="",style="solid", color="black", weight=3];
8[label="takeWhile (flip ltEsMyInt vz31) (Cons vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];8 -> 9[label="",style="solid", color="black", weight=3];
9[label="takeWhile2 (flip ltEsMyInt vz31) (Cons vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];9 -> 10[label="",style="solid", color="black", weight=3];
10[label="takeWhile1 (flip ltEsMyInt vz31) vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))) (flip ltEsMyInt vz31 vz30)",fontsize=16,color="black",shape="box"];10 -> 11[label="",style="solid", color="black", weight=3];
11[label="takeWhile1 (flip ltEsMyInt vz31) vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))) (ltEsMyInt vz30 vz31)",fontsize=16,color="black",shape="box"];11 -> 12[label="",style="solid", color="black", weight=3];
12[label="takeWhile1 (flip ltEsMyInt vz31) vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))) (fsEsOrdering (compareMyInt vz30 vz31) GT)",fontsize=16,color="black",shape="box"];12 -> 13[label="",style="solid", color="black", weight=3];
13[label="takeWhile1 (flip ltEsMyInt vz31) vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (compareMyInt vz30 vz31) GT))",fontsize=16,color="black",shape="box"];13 -> 14[label="",style="solid", color="black", weight=3];
14[label="takeWhile1 (flip ltEsMyInt vz31) vz30 (dsEm numericEnumFrom (psMyInt vz30 (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt vz30 vz31) GT))",fontsize=16,color="burlywood",shape="box"];812[label="vz30/Pos vz300",fontsize=10,color="white",style="solid",shape="box"];14 -> 812[label="",style="solid", color="burlywood", weight=9];
812 -> 15[label="",style="solid", color="burlywood", weight=3];
813[label="vz30/Neg vz300",fontsize=10,color="white",style="solid",shape="box"];14 -> 813[label="",style="solid", color="burlywood", weight=9];
813 -> 16[label="",style="solid", color="burlywood", weight=3];
15[label="takeWhile1 (flip ltEsMyInt vz31) (Pos vz300) (dsEm numericEnumFrom (psMyInt (Pos vz300) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos vz300) vz31) GT))",fontsize=16,color="burlywood",shape="box"];814[label="vz300/Succ vz3000",fontsize=10,color="white",style="solid",shape="box"];15 -> 814[label="",style="solid", color="burlywood", weight=9];
814 -> 17[label="",style="solid", color="burlywood", weight=3];
815[label="vz300/Zero",fontsize=10,color="white",style="solid",shape="box"];15 -> 815[label="",style="solid", color="burlywood", weight=9];
815 -> 18[label="",style="solid", color="burlywood", weight=3];
16[label="takeWhile1 (flip ltEsMyInt vz31) (Neg vz300) (dsEm numericEnumFrom (psMyInt (Neg vz300) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg vz300) vz31) GT))",fontsize=16,color="burlywood",shape="box"];816[label="vz300/Succ vz3000",fontsize=10,color="white",style="solid",shape="box"];16 -> 816[label="",style="solid", color="burlywood", weight=9];
816 -> 19[label="",style="solid", color="burlywood", weight=3];
817[label="vz300/Zero",fontsize=10,color="white",style="solid",shape="box"];16 -> 817[label="",style="solid", color="burlywood", weight=9];
817 -> 20[label="",style="solid", color="burlywood", weight=3];
17[label="takeWhile1 (flip ltEsMyInt vz31) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz3000)) vz31) GT))",fontsize=16,color="burlywood",shape="box"];818[label="vz31/Pos vz310",fontsize=10,color="white",style="solid",shape="box"];17 -> 818[label="",style="solid", color="burlywood", weight=9];
818 -> 21[label="",style="solid", color="burlywood", weight=3];
819[label="vz31/Neg vz310",fontsize=10,color="white",style="solid",shape="box"];17 -> 819[label="",style="solid", color="burlywood", weight=9];
819 -> 22[label="",style="solid", color="burlywood", weight=3];
18[label="takeWhile1 (flip ltEsMyInt vz31) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) vz31) GT))",fontsize=16,color="burlywood",shape="box"];820[label="vz31/Pos vz310",fontsize=10,color="white",style="solid",shape="box"];18 -> 820[label="",style="solid", color="burlywood", weight=9];
820 -> 23[label="",style="solid", color="burlywood", weight=3];
821[label="vz31/Neg vz310",fontsize=10,color="white",style="solid",shape="box"];18 -> 821[label="",style="solid", color="burlywood", weight=9];
821 -> 24[label="",style="solid", color="burlywood", weight=3];
19[label="takeWhile1 (flip ltEsMyInt vz31) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz3000)) vz31) GT))",fontsize=16,color="burlywood",shape="box"];822[label="vz31/Pos vz310",fontsize=10,color="white",style="solid",shape="box"];19 -> 822[label="",style="solid", color="burlywood", weight=9];
822 -> 25[label="",style="solid", color="burlywood", weight=3];
823[label="vz31/Neg vz310",fontsize=10,color="white",style="solid",shape="box"];19 -> 823[label="",style="solid", color="burlywood", weight=9];
823 -> 26[label="",style="solid", color="burlywood", weight=3];
20[label="takeWhile1 (flip ltEsMyInt vz31) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) vz31) GT))",fontsize=16,color="burlywood",shape="box"];824[label="vz31/Pos vz310",fontsize=10,color="white",style="solid",shape="box"];20 -> 824[label="",style="solid", color="burlywood", weight=9];
824 -> 27[label="",style="solid", color="burlywood", weight=3];
825[label="vz31/Neg vz310",fontsize=10,color="white",style="solid",shape="box"];20 -> 825[label="",style="solid", color="burlywood", weight=9];
825 -> 28[label="",style="solid", color="burlywood", weight=3];
21[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz3000)) (Pos vz310)) GT))",fontsize=16,color="black",shape="box"];21 -> 29[label="",style="solid", color="black", weight=3];
22[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos (Succ vz3000)) (Neg vz310)) GT))",fontsize=16,color="black",shape="box"];22 -> 30[label="",style="solid", color="black", weight=3];
23[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Pos vz310)) GT))",fontsize=16,color="burlywood",shape="box"];826[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];23 -> 826[label="",style="solid", color="burlywood", weight=9];
826 -> 31[label="",style="solid", color="burlywood", weight=3];
827[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];23 -> 827[label="",style="solid", color="burlywood", weight=9];
827 -> 32[label="",style="solid", color="burlywood", weight=3];
24[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Neg vz310)) GT))",fontsize=16,color="burlywood",shape="box"];828[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];24 -> 828[label="",style="solid", color="burlywood", weight=9];
828 -> 33[label="",style="solid", color="burlywood", weight=3];
829[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];24 -> 829[label="",style="solid", color="burlywood", weight=9];
829 -> 34[label="",style="solid", color="burlywood", weight=3];
25[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz3000)) (Pos vz310)) GT))",fontsize=16,color="black",shape="box"];25 -> 35[label="",style="solid", color="black", weight=3];
26[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg (Succ vz3000)) (Neg vz310)) GT))",fontsize=16,color="black",shape="box"];26 -> 36[label="",style="solid", color="black", weight=3];
27[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Pos vz310)) GT))",fontsize=16,color="burlywood",shape="box"];830[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];27 -> 830[label="",style="solid", color="burlywood", weight=9];
830 -> 37[label="",style="solid", color="burlywood", weight=3];
831[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];27 -> 831[label="",style="solid", color="burlywood", weight=9];
831 -> 38[label="",style="solid", color="burlywood", weight=3];
28[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Neg vz310)) GT))",fontsize=16,color="burlywood",shape="box"];832[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];28 -> 832[label="",style="solid", color="burlywood", weight=9];
832 -> 39[label="",style="solid", color="burlywood", weight=3];
833[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];28 -> 833[label="",style="solid", color="burlywood", weight=9];
833 -> 40[label="",style="solid", color="burlywood", weight=3];
29[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz3000) vz310) GT))",fontsize=16,color="burlywood",shape="box"];834[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];29 -> 834[label="",style="solid", color="burlywood", weight=9];
834 -> 41[label="",style="solid", color="burlywood", weight=3];
835[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];29 -> 835[label="",style="solid", color="burlywood", weight=9];
835 -> 42[label="",style="solid", color="burlywood", weight=3];
30[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];30 -> 43[label="",style="solid", color="black", weight=3];
31[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Pos (Succ vz3100))) GT))",fontsize=16,color="black",shape="box"];31 -> 44[label="",style="solid", color="black", weight=3];
32[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"];32 -> 45[label="",style="solid", color="black", weight=3];
33[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Pos Zero) (Neg (Succ vz3100))) GT))",fontsize=16,color="black",shape="box"];33 -> 46[label="",style="solid", color="black", weight=3];
34[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"];34 -> 47[label="",style="solid", color="black", weight=3];
35[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];35 -> 48[label="",style="solid", color="black", weight=3];
36[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz310 (Succ vz3000)) GT))",fontsize=16,color="burlywood",shape="box"];836[label="vz310/Succ vz3100",fontsize=10,color="white",style="solid",shape="box"];36 -> 836[label="",style="solid", color="burlywood", weight=9];
836 -> 49[label="",style="solid", color="burlywood", weight=3];
837[label="vz310/Zero",fontsize=10,color="white",style="solid",shape="box"];36 -> 837[label="",style="solid", color="burlywood", weight=9];
837 -> 50[label="",style="solid", color="burlywood", weight=3];
37[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Pos (Succ vz3100))) GT))",fontsize=16,color="black",shape="box"];37 -> 51[label="",style="solid", color="black", weight=3];
38[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"];38 -> 52[label="",style="solid", color="black", weight=3];
39[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpInt (Neg Zero) (Neg (Succ vz3100))) GT))",fontsize=16,color="black",shape="box"];39 -> 53[label="",style="solid", color="black", weight=3];
40[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"];40 -> 54[label="",style="solid", color="black", weight=3];
41[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz3000) (Succ vz3100)) GT))",fontsize=16,color="black",shape="box"];41 -> 55[label="",style="solid", color="black", weight=3];
42[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz3000) Zero) GT))",fontsize=16,color="black",shape="box"];42 -> 56[label="",style="solid", color="black", weight=3];
43[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];43 -> 57[label="",style="solid", color="black", weight=3];
44[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz3100)) GT))",fontsize=16,color="black",shape="box"];44 -> 58[label="",style="solid", color="black", weight=3];
45[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"];45 -> 59[label="",style="solid", color="black", weight=3];
46[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];46 -> 60[label="",style="solid", color="black", weight=3];
47[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"];47 -> 61[label="",style="solid", color="black", weight=3];
48[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];48 -> 62[label="",style="solid", color="black", weight=3];
49[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz3100) (Succ vz3000)) GT))",fontsize=16,color="black",shape="box"];49 -> 63[label="",style="solid", color="black", weight=3];
50[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz3000)) GT))",fontsize=16,color="black",shape="box"];50 -> 64[label="",style="solid", color="black", weight=3];
51[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];51 -> 65[label="",style="solid", color="black", weight=3];
52[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"];52 -> 66[label="",style="solid", color="black", weight=3];
53[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz3100) Zero) GT))",fontsize=16,color="black",shape="box"];53 -> 67[label="",style="solid", color="black", weight=3];
54[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"];54 -> 68[label="",style="solid", color="black", weight=3];
55 -> 447[label="",style="dashed", color="red", weight=0];
55[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz3000 vz3100) GT))",fontsize=16,color="magenta"];55 -> 448[label="",style="dashed", color="magenta", weight=3];
55 -> 449[label="",style="dashed", color="magenta", weight=3];
55 -> 450[label="",style="dashed", color="magenta", weight=3];
55 -> 451[label="",style="dashed", color="magenta", weight=3];
56[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];56 -> 71[label="",style="solid", color="black", weight=3];
57[label="takeWhile1 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];57 -> 72[label="",style="solid", color="black", weight=3];
58[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];58 -> 73[label="",style="solid", color="black", weight=3];
59[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"];59 -> 74[label="",style="solid", color="black", weight=3];
60[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];60 -> 75[label="",style="solid", color="black", weight=3];
61[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"];61 -> 76[label="",style="solid", color="black", weight=3];
62[label="takeWhile1 (flip ltEsMyInt (Pos vz310)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];62 -> 77[label="",style="solid", color="black", weight=3];
63 -> 723[label="",style="dashed", color="red", weight=0];
63[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz3100 vz3000) GT))",fontsize=16,color="magenta"];63 -> 724[label="",style="dashed", color="magenta", weight=3];
63 -> 725[label="",style="dashed", color="magenta", weight=3];
63 -> 726[label="",style="dashed", color="magenta", weight=3];
63 -> 727[label="",style="dashed", color="magenta", weight=3];
63 -> 728[label="",style="dashed", color="magenta", weight=3];
64[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];64 -> 80[label="",style="solid", color="black", weight=3];
65[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (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 (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];66 -> 82[label="",style="solid", color="black", weight=3];
67[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];67 -> 83[label="",style="solid", color="black", weight=3];
68[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"];68 -> 84[label="",style="solid", color="black", weight=3];
448[label="vz3100",fontsize=16,color="green",shape="box"];449[label="vz3000",fontsize=16,color="green",shape="box"];450[label="vz3100",fontsize=16,color="green",shape="box"];451[label="vz3000",fontsize=16,color="green",shape="box"];447[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz23 vz24) GT))",fontsize=16,color="burlywood",shape="triangle"];838[label="vz23/Succ vz230",fontsize=10,color="white",style="solid",shape="box"];447 -> 838[label="",style="solid", color="burlywood", weight=9];
838 -> 476[label="",style="solid", color="burlywood", weight=3];
839[label="vz23/Zero",fontsize=10,color="white",style="solid",shape="box"];447 -> 839[label="",style="solid", color="burlywood", weight=9];
839 -> 477[label="",style="solid", color="burlywood", weight=3];
71[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];71 -> 89[label="",style="solid", color="black", weight=3];
72[label="takeWhile0 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];72 -> 90[label="",style="solid", color="black", weight=3];
73[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];73 -> 91[label="",style="solid", color="black", weight=3];
74[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];74 -> 92[label="",style="solid", color="black", weight=3];
75[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];75 -> 93[label="",style="solid", color="black", weight=3];
76[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];76 -> 94[label="",style="solid", color="black", weight=3];
77[label="Cons (Neg (Succ vz3000)) (takeWhile (flip ltEsMyInt (Pos vz310)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];77 -> 95[label="",style="dashed", color="green", weight=3];
724[label="vz3100",fontsize=16,color="green",shape="box"];725[label="vz3000",fontsize=16,color="green",shape="box"];726 -> 180[label="",style="dashed", color="red", weight=0];
726[label="psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];727[label="vz3100",fontsize=16,color="green",shape="box"];728[label="vz3000",fontsize=16,color="green",shape="box"];723[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat vz67 vz68) GT))",fontsize=16,color="burlywood",shape="triangle"];840[label="vz67/Succ vz670",fontsize=10,color="white",style="solid",shape="box"];723 -> 840[label="",style="solid", color="burlywood", weight=9];
840 -> 779[label="",style="solid", color="burlywood", weight=3];
841[label="vz67/Zero",fontsize=10,color="white",style="solid",shape="box"];723 -> 841[label="",style="solid", color="burlywood", weight=9];
841 -> 780[label="",style="solid", color="burlywood", weight=3];
80[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="box"];80 -> 100[label="",style="solid", color="black", weight=3];
81[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (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 (Pos Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];82 -> 102[label="",style="solid", color="black", weight=3];
83[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];83 -> 103[label="",style="solid", color="black", weight=3];
84[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];84 -> 104[label="",style="solid", color="black", weight=3];
476[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz230) vz24) GT))",fontsize=16,color="burlywood",shape="box"];842[label="vz24/Succ vz240",fontsize=10,color="white",style="solid",shape="box"];476 -> 842[label="",style="solid", color="burlywood", weight=9];
842 -> 483[label="",style="solid", color="burlywood", weight=3];
843[label="vz24/Zero",fontsize=10,color="white",style="solid",shape="box"];476 -> 843[label="",style="solid", color="burlywood", weight=9];
843 -> 484[label="",style="solid", color="burlywood", weight=3];
477[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero vz24) GT))",fontsize=16,color="burlywood",shape="box"];844[label="vz24/Succ vz240",fontsize=10,color="white",style="solid",shape="box"];477 -> 844[label="",style="solid", color="burlywood", weight=9];
844 -> 485[label="",style="solid", color="burlywood", weight=3];
845[label="vz24/Zero",fontsize=10,color="white",style="solid",shape="box"];477 -> 845[label="",style="solid", color="burlywood", weight=9];
845 -> 486[label="",style="solid", color="burlywood", weight=3];
89[label="takeWhile1 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];89 -> 109[label="",style="solid", color="black", weight=3];
90[label="takeWhile0 (flip ltEsMyInt (Neg vz310)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];90 -> 110[label="",style="solid", color="black", weight=3];
91[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];91 -> 111[label="",style="solid", color="black", weight=3];
92[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];92 -> 112[label="",style="dashed", color="green", weight=3];
93[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];93 -> 113[label="",style="solid", color="black", weight=3];
94[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];94 -> 114[label="",style="dashed", color="green", weight=3];
95[label="takeWhile (flip ltEsMyInt (Pos vz310)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];95 -> 115[label="",style="solid", color="black", weight=3];
180[label="psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];180 -> 206[label="",style="solid", color="black", weight=3];
779[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat (Succ vz670) vz68) GT))",fontsize=16,color="burlywood",shape="box"];846[label="vz68/Succ vz680",fontsize=10,color="white",style="solid",shape="box"];779 -> 846[label="",style="solid", color="burlywood", weight=9];
846 -> 782[label="",style="solid", color="burlywood", weight=3];
847[label="vz68/Zero",fontsize=10,color="white",style="solid",shape="box"];779 -> 847[label="",style="solid", color="burlywood", weight=9];
847 -> 783[label="",style="solid", color="burlywood", weight=3];
780[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat Zero vz68) GT))",fontsize=16,color="burlywood",shape="box"];848[label="vz68/Succ vz680",fontsize=10,color="white",style="solid",shape="box"];780 -> 848[label="",style="solid", color="burlywood", weight=9];
848 -> 784[label="",style="solid", color="burlywood", weight=3];
849[label="vz68/Zero",fontsize=10,color="white",style="solid",shape="box"];780 -> 849[label="",style="solid", color="burlywood", weight=9];
849 -> 785[label="",style="solid", color="burlywood", weight=3];
100[label="takeWhile1 (flip ltEsMyInt (Neg Zero)) (Neg (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];100 -> 120[label="",style="solid", color="black", weight=3];
101[label="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (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="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];102 -> 122[label="",style="dashed", color="green", weight=3];
103[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];103 -> 123[label="",style="solid", color="black", weight=3];
104[label="Cons (Neg Zero) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];104 -> 124[label="",style="dashed", color="green", weight=3];
483[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz230) (Succ vz240)) GT))",fontsize=16,color="black",shape="box"];483 -> 490[label="",style="solid", color="black", weight=3];
484[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat (Succ vz230) Zero) GT))",fontsize=16,color="black",shape="box"];484 -> 491[label="",style="solid", color="black", weight=3];
485[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero (Succ vz240)) GT))",fontsize=16,color="black",shape="box"];485 -> 492[label="",style="solid", color="black", weight=3];
486[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat Zero Zero) GT))",fontsize=16,color="black",shape="box"];486 -> 493[label="",style="solid", color="black", weight=3];
109[label="takeWhile0 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];109 -> 130[label="",style="solid", color="black", weight=3];
110[label="Nil",fontsize=16,color="green",shape="box"];111[label="Cons (Pos Zero) (takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];111 -> 131[label="",style="dashed", color="green", weight=3];
112[label="takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];112 -> 132[label="",style="solid", color="black", weight=3];
113[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz3100))) (Pos Zero) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];113 -> 133[label="",style="solid", color="black", weight=3];
114[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];114 -> 134[label="",style="solid", color="black", weight=3];
115[label="takeWhile (flip ltEsMyInt (Pos vz310)) (seq (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];115 -> 135[label="",style="solid", color="black", weight=3];
206[label="primPlusInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];206 -> 245[label="",style="solid", color="black", weight=3];
782[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat (Succ vz670) (Succ vz680)) GT))",fontsize=16,color="black",shape="box"];782 -> 788[label="",style="solid", color="black", weight=3];
783[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat (Succ vz670) Zero) GT))",fontsize=16,color="black",shape="box"];783 -> 789[label="",style="solid", color="black", weight=3];
784[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat Zero (Succ vz680)) GT))",fontsize=16,color="black",shape="box"];784 -> 790[label="",style="solid", color="black", weight=3];
785[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat Zero Zero) GT))",fontsize=16,color="black",shape="box"];785 -> 791[label="",style="solid", color="black", weight=3];
120[label="Cons (Neg (Succ vz3000)) (takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];120 -> 141[label="",style="dashed", color="green", weight=3];
121[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (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="takeWhile (flip ltEsMyInt (Pos Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];122 -> 143[label="",style="solid", color="black", weight=3];
123[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];123 -> 144[label="",style="solid", color="black", weight=3];
124[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];124 -> 145[label="",style="solid", color="black", weight=3];
490 -> 447[label="",style="dashed", color="red", weight=0];
490[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering (primCmpNat vz230 vz240) GT))",fontsize=16,color="magenta"];490 -> 505[label="",style="dashed", color="magenta", weight=3];
490 -> 506[label="",style="dashed", color="magenta", weight=3];
491[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];491 -> 507[label="",style="solid", color="black", weight=3];
492[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];492 -> 508[label="",style="solid", color="black", weight=3];
493[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];493 -> 509[label="",style="solid", color="black", weight=3];
130[label="takeWhile0 (flip ltEsMyInt (Pos Zero)) (Pos (Succ vz3000)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];130 -> 153[label="",style="solid", color="black", weight=3];
131[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (dsEm 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="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"];132 -> 155[label="",style="solid", color="black", weight=3];
133[label="Nil",fontsize=16,color="green",shape="box"];134[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"];134 -> 156[label="",style="solid", color="black", weight=3];
135[label="takeWhile (flip ltEsMyInt (Pos vz310)) (enforceWHNF (WHNF (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];135 -> 157[label="",style="solid", color="black", weight=3];
245[label="primPlusInt (Neg (Succ vz3000)) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];245 -> 273[label="",style="solid", color="black", weight=3];
788 -> 723[label="",style="dashed", color="red", weight=0];
788[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering (primCmpNat vz670 vz680) GT))",fontsize=16,color="magenta"];788 -> 794[label="",style="dashed", color="magenta", weight=3];
788 -> 795[label="",style="dashed", color="magenta", weight=3];
789[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering GT GT))",fontsize=16,color="black",shape="box"];789 -> 796[label="",style="solid", color="black", weight=3];
790[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering LT GT))",fontsize=16,color="black",shape="box"];790 -> 797[label="",style="solid", color="black", weight=3];
791[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not (esEsOrdering EQ GT))",fontsize=16,color="black",shape="box"];791 -> 798[label="",style="solid", color="black", weight=3];
141[label="takeWhile (flip ltEsMyInt (Neg Zero)) (dsEm numericEnumFrom (psMyInt (Neg (Succ vz3000)) (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 (Succ vz3100))) (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="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"];143 -> 167[label="",style="solid", color="black", weight=3];
144[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz3100))) (Neg Zero) (dsEm numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];144 -> 168[label="",style="solid", color="black", weight=3];
145[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"];145 -> 169[label="",style="solid", color="black", weight=3];
505[label="vz240",fontsize=16,color="green",shape="box"];506[label="vz230",fontsize=16,color="green",shape="box"];507[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not MyTrue)",fontsize=16,color="black",shape="box"];507 -> 521[label="",style="solid", color="black", weight=3];
508[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="black",shape="triangle"];508 -> 522[label="",style="solid", color="black", weight=3];
509 -> 508[label="",style="dashed", color="red", weight=0];
509[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (not MyFalse)",fontsize=16,color="magenta"];153[label="Nil",fontsize=16,color="green",shape="box"];154[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (seq (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[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"];155 -> 178[label="",style="solid", color="black", weight=3];
156 -> 219[label="",style="dashed", color="red", weight=0];
156[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"];156 -> 220[label="",style="dashed", color="magenta", weight=3];
156 -> 221[label="",style="dashed", color="magenta", weight=3];
157 -> 7[label="",style="dashed", color="red", weight=0];
157[label="takeWhile (flip ltEsMyInt (Pos vz310)) (numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];157 -> 180[label="",style="dashed", color="magenta", weight=3];
157 -> 181[label="",style="dashed", color="magenta", weight=3];
273[label="primMinusNat (Succ Zero) (Succ vz3000)",fontsize=16,color="black",shape="box"];273 -> 297[label="",style="solid", color="black", weight=3];
794[label="vz680",fontsize=16,color="green",shape="box"];795[label="vz670",fontsize=16,color="green",shape="box"];796[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not MyTrue)",fontsize=16,color="black",shape="box"];796 -> 799[label="",style="solid", color="black", weight=3];
797[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not MyFalse)",fontsize=16,color="black",shape="triangle"];797 -> 800[label="",style="solid", color="black", weight=3];
798 -> 797[label="",style="dashed", color="red", weight=0];
798[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) (not MyFalse)",fontsize=16,color="magenta"];165[label="takeWhile (flip ltEsMyInt (Neg Zero)) (seq (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Neg (Succ vz3000)) (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 (Succ vz3100))) (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="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"];167 -> 191[label="",style="solid", color="black", weight=3];
168[label="Nil",fontsize=16,color="green",shape="box"];169 -> 219[label="",style="dashed", color="red", weight=0];
169[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"];169 -> 222[label="",style="dashed", color="magenta", weight=3];
169 -> 223[label="",style="dashed", color="magenta", weight=3];
521[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) MyFalse",fontsize=16,color="black",shape="box"];521 -> 530[label="",style="solid", color="black", weight=3];
522[label="takeWhile1 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];522 -> 531[label="",style="solid", color="black", weight=3];
177[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (enforceWHNF (WHNF (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];177 -> 201[label="",style="solid", color="black", weight=3];
178 -> 7[label="",style="dashed", color="red", weight=0];
178[label="takeWhile (flip ltEsMyInt (Pos Zero)) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];178 -> 202[label="",style="dashed", color="magenta", weight=3];
178 -> 203[label="",style="dashed", color="magenta", weight=3];
220[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];220 -> 226[label="",style="solid", color="black", weight=3];
221 -> 220[label="",style="dashed", color="red", weight=0];
221[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];219[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF vz10) (numericEnumFrom vz9))",fontsize=16,color="black",shape="triangle"];219 -> 227[label="",style="solid", color="black", weight=3];
181[label="Pos vz310",fontsize=16,color="green",shape="box"];297[label="primMinusNat Zero vz3000",fontsize=16,color="burlywood",shape="box"];850[label="vz3000/Succ vz30000",fontsize=10,color="white",style="solid",shape="box"];297 -> 850[label="",style="solid", color="burlywood", weight=9];
850 -> 322[label="",style="solid", color="burlywood", weight=3];
851[label="vz3000/Zero",fontsize=10,color="white",style="solid",shape="box"];297 -> 851[label="",style="solid", color="burlywood", weight=9];
851 -> 323[label="",style="solid", color="burlywood", weight=3];
799[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) MyFalse",fontsize=16,color="black",shape="box"];799 -> 801[label="",style="solid", color="black", weight=3];
800[label="takeWhile1 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) MyTrue",fontsize=16,color="black",shape="box"];800 -> 802[label="",style="solid", color="black", weight=3];
189 -> 219[label="",style="dashed", color="red", weight=0];
189[label="takeWhile (flip ltEsMyInt (Neg Zero)) (enforceWHNF (WHNF (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="magenta"];189 -> 224[label="",style="dashed", color="magenta", weight=3];
189 -> 225[label="",style="dashed", color="magenta", weight=3];
190 -> 7[label="",style="dashed", color="red", weight=0];
190[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];190 -> 228[label="",style="dashed", color="magenta", weight=3];
190 -> 229[label="",style="dashed", color="magenta", weight=3];
191 -> 7[label="",style="dashed", color="red", weight=0];
191[label="takeWhile (flip ltEsMyInt (Pos Zero)) (numericEnumFrom (psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];191 -> 230[label="",style="dashed", color="magenta", weight=3];
191 -> 231[label="",style="dashed", color="magenta", weight=3];
222[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="triangle"];222 -> 232[label="",style="solid", color="black", weight=3];
223 -> 222[label="",style="dashed", color="red", weight=0];
223[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];530[label="takeWhile0 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) otherwise",fontsize=16,color="black",shape="box"];530 -> 536[label="",style="solid", color="black", weight=3];
531[label="Cons (Pos (Succ vz22)) (takeWhile (flip ltEsMyInt (Pos (Succ vz21))) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="green",shape="box"];531 -> 537[label="",style="dashed", color="green", weight=3];
201 -> 7[label="",style="dashed", color="red", weight=0];
201[label="takeWhile (flip ltEsMyInt (Pos (Succ vz3100))) (numericEnumFrom (psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];201 -> 243[label="",style="dashed", color="magenta", weight=3];
201 -> 244[label="",style="dashed", color="magenta", weight=3];
202 -> 220[label="",style="dashed", color="red", weight=0];
202[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];203[label="Pos Zero",fontsize=16,color="green",shape="box"];226[label="primPlusInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];226 -> 260[label="",style="solid", color="black", weight=3];
227 -> 7[label="",style="dashed", color="red", weight=0];
227[label="takeWhile (flip ltEsMyInt (Neg Zero)) (numericEnumFrom vz9)",fontsize=16,color="magenta"];227 -> 261[label="",style="dashed", color="magenta", weight=3];
227 -> 262[label="",style="dashed", color="magenta", weight=3];
322[label="primMinusNat Zero (Succ vz30000)",fontsize=16,color="black",shape="box"];322 -> 344[label="",style="solid", color="black", weight=3];
323[label="primMinusNat Zero Zero",fontsize=16,color="black",shape="box"];323 -> 345[label="",style="solid", color="black", weight=3];
801[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) otherwise",fontsize=16,color="black",shape="box"];801 -> 803[label="",style="solid", color="black", weight=3];
802[label="Cons (Neg (Succ vz65)) (takeWhile (flip ltEsMyInt (Neg (Succ vz64))) (dsEm numericEnumFrom vz66))",fontsize=16,color="green",shape="box"];802 -> 804[label="",style="dashed", color="green", weight=3];
224 -> 180[label="",style="dashed", color="red", weight=0];
224[label="psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];225 -> 180[label="",style="dashed", color="red", weight=0];
225[label="psMyInt (Neg (Succ vz3000)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];228 -> 222[label="",style="dashed", color="red", weight=0];
228[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];229[label="Pos (Succ vz3100)",fontsize=16,color="green",shape="box"];230 -> 222[label="",style="dashed", color="red", weight=0];
230[label="psMyInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];231[label="Pos Zero",fontsize=16,color="green",shape="box"];232[label="primPlusInt (Neg Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];232 -> 263[label="",style="solid", color="black", weight=3];
536[label="takeWhile0 (flip ltEsMyInt (Pos (Succ vz21))) (Pos (Succ vz22)) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) MyTrue",fontsize=16,color="black",shape="box"];536 -> 542[label="",style="solid", color="black", weight=3];
537[label="takeWhile (flip ltEsMyInt (Pos (Succ vz21))) (dsEm numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="black",shape="box"];537 -> 543[label="",style="solid", color="black", weight=3];
243 -> 220[label="",style="dashed", color="red", weight=0];
243[label="psMyInt (Pos Zero) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="magenta"];244[label="Pos (Succ vz3100)",fontsize=16,color="green",shape="box"];260[label="primPlusInt (Pos Zero) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];260 -> 285[label="",style="solid", color="black", weight=3];
261[label="vz9",fontsize=16,color="green",shape="box"];262[label="Neg Zero",fontsize=16,color="green",shape="box"];344[label="Neg (Succ vz30000)",fontsize=16,color="green",shape="box"];345[label="Pos Zero",fontsize=16,color="green",shape="box"];803[label="takeWhile0 (flip ltEsMyInt (Neg (Succ vz64))) (Neg (Succ vz65)) (dsEm numericEnumFrom vz66) MyTrue",fontsize=16,color="black",shape="box"];803 -> 805[label="",style="solid", color="black", weight=3];
804[label="takeWhile (flip ltEsMyInt (Neg (Succ vz64))) (dsEm numericEnumFrom vz66)",fontsize=16,color="black",shape="box"];804 -> 806[label="",style="solid", color="black", weight=3];
263[label="primPlusInt (Neg Zero) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];263 -> 286[label="",style="solid", color="black", weight=3];
542[label="Nil",fontsize=16,color="green",shape="box"];543[label="takeWhile (flip ltEsMyInt (Pos (Succ vz21))) (seq (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero)))) (numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];543 -> 547[label="",style="solid", color="black", weight=3];
285[label="Pos (primPlusNat Zero (Succ Zero))",fontsize=16,color="green",shape="box"];285 -> 306[label="",style="dashed", color="green", weight=3];
805[label="Nil",fontsize=16,color="green",shape="box"];806[label="takeWhile (flip ltEsMyInt (Neg (Succ vz64))) (seq vz66 (numericEnumFrom vz66))",fontsize=16,color="black",shape="box"];806 -> 807[label="",style="solid", color="black", weight=3];
286[label="primMinusNat (Succ Zero) Zero",fontsize=16,color="black",shape="box"];286 -> 307[label="",style="solid", color="black", weight=3];
547[label="takeWhile (flip ltEsMyInt (Pos (Succ vz21))) (enforceWHNF (WHNF (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))) (numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero))))))",fontsize=16,color="black",shape="box"];547 -> 583[label="",style="solid", color="black", weight=3];
306[label="primPlusNat Zero (Succ Zero)",fontsize=16,color="black",shape="box"];306 -> 333[label="",style="solid", color="black", weight=3];
807[label="takeWhile (flip ltEsMyInt (Neg (Succ vz64))) (enforceWHNF (WHNF vz66) (numericEnumFrom vz66))",fontsize=16,color="black",shape="box"];807 -> 808[label="",style="solid", color="black", weight=3];
307[label="Pos (Succ Zero)",fontsize=16,color="green",shape="box"];583 -> 7[label="",style="dashed", color="red", weight=0];
583[label="takeWhile (flip ltEsMyInt (Pos (Succ vz21))) (numericEnumFrom (psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero)))))",fontsize=16,color="magenta"];583 -> 619[label="",style="dashed", color="magenta", weight=3];
583 -> 620[label="",style="dashed", color="magenta", weight=3];
333[label="Succ Zero",fontsize=16,color="green",shape="box"];808 -> 7[label="",style="dashed", color="red", weight=0];
808[label="takeWhile (flip ltEsMyInt (Neg (Succ vz64))) (numericEnumFrom vz66)",fontsize=16,color="magenta"];808 -> 809[label="",style="dashed", color="magenta", weight=3];
808 -> 810[label="",style="dashed", color="magenta", weight=3];
619[label="psMyInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];619 -> 650[label="",style="solid", color="black", weight=3];
620[label="Pos (Succ vz21)",fontsize=16,color="green",shape="box"];809[label="vz66",fontsize=16,color="green",shape="box"];810[label="Neg (Succ vz64)",fontsize=16,color="green",shape="box"];650[label="primPlusInt (Pos (Succ vz22)) (fromIntMyInt (Pos (Succ Zero)))",fontsize=16,color="black",shape="box"];650 -> 663[label="",style="solid", color="black", weight=3];
663[label="primPlusInt (Pos (Succ vz22)) (Pos (Succ Zero))",fontsize=16,color="black",shape="box"];663 -> 701[label="",style="solid", color="black", weight=3];
701[label="Pos (primPlusNat (Succ vz22) (Succ Zero))",fontsize=16,color="green",shape="box"];701 -> 713[label="",style="dashed", color="green", weight=3];
713[label="primPlusNat (Succ vz22) (Succ Zero)",fontsize=16,color="black",shape="box"];713 -> 722[label="",style="solid", color="black", weight=3];
722[label="Succ (Succ (primPlusNat vz22 Zero))",fontsize=16,color="green",shape="box"];722 -> 781[label="",style="dashed", color="green", weight=3];
781[label="primPlusNat vz22 Zero",fontsize=16,color="burlywood",shape="box"];852[label="vz22/Succ vz220",fontsize=10,color="white",style="solid",shape="box"];781 -> 852[label="",style="solid", color="burlywood", weight=9];
852 -> 786[label="",style="solid", color="burlywood", weight=3];
853[label="vz22/Zero",fontsize=10,color="white",style="solid",shape="box"];781 -> 853[label="",style="solid", color="burlywood", weight=9];
853 -> 787[label="",style="solid", color="burlywood", weight=3];
786[label="primPlusNat (Succ vz220) Zero",fontsize=16,color="black",shape="box"];786 -> 792[label="",style="solid", color="black", weight=3];
787[label="primPlusNat Zero Zero",fontsize=16,color="black",shape="box"];787 -> 793[label="",style="solid", color="black", weight=3];
792[label="Succ vz220",fontsize=16,color="green",shape="box"];793[label="Zero",fontsize=16,color="green",shape="box"];}

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

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

   new_takeWhile12(vz64, vz65, vz66) -> new_takeWhile(Main.Neg(Main.Succ(vz64)), vz66)
   new_takeWhile(Main.Pos(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Zero), new_psMyInt)
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> new_takeWhile1(vz3100, vz3000, vz3000, vz3100)
   new_takeWhile(Main.Neg(Main.Zero), Main.Pos(Main.Zero)) -> new_takeWhile0(new_psMyInt, new_psMyInt)
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Neg(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Succ(vz3100)), new_psMyInt1)
   new_takeWhile1(vz21, vz22, Main.Succ(vz230), Main.Succ(vz240)) -> new_takeWhile1(vz21, vz22, vz230, vz240)
   new_takeWhile11(vz64, vz65, vz66, Main.Zero, Main.Succ(vz680)) -> new_takeWhile(Main.Neg(Main.Succ(vz64)), vz66)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Pos(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Zero), new_psMyInt1)
   new_takeWhile11(vz64, vz65, vz66, Main.Succ(vz670), Main.Succ(vz680)) -> new_takeWhile11(vz64, vz65, vz66, vz670, vz680)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Zero)) -> new_takeWhile(Main.Pos(Main.Succ(vz3100)), new_psMyInt)
   new_takeWhile11(vz64, vz65, vz66, Main.Zero, Main.Zero) -> new_takeWhile12(vz64, vz65, vz66)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Neg(Main.Succ(vz3100)), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile11(vz3100, vz3000, new_psMyInt0(vz3000), vz3100, vz3000)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Zero)) -> new_takeWhile0(new_psMyInt1, new_psMyInt1)
   new_takeWhile(Main.Pos(vz310), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile(Main.Pos(vz310), new_psMyInt0(vz3000))
   new_takeWhile0(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   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(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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(vz220)) -> Main.Succ(vz220)

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   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(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))

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(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   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(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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.Succ(x0))
   new_primPlusNat(Main.Zero)


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

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

   new_takeWhile0(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   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(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   new_takeWhile(Main.Neg(Main.Zero), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz3000))) -> new_takeWhile0(new_psMyInt0(vz3000), new_psMyInt0(vz3000))
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(vz30000)) -> Main.Neg(Main.Succ(vz30000))


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

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

   new_takeWhile0(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9)
   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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz10, vz9) -> new_takeWhile(Main.Neg(Main.Zero), vz9) 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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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(vz21, vz22, Main.Succ(vz230), Main.Succ(vz240)) -> new_takeWhile1(vz21, vz22, vz230, vz240)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> new_takeWhile1(vz3100, vz3000, vz3000, vz3100)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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

(37) QDPPairToRuleProof (EQUIVALENT)
The dependency pair new_takeWhile1(vz21, vz22, Main.Succ(vz230), Main.Succ(vz240)) -> new_takeWhile1(vz21, vz22, vz230, vz240) was transformed to the following new rules:
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))

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

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

(38)
Complex Obligation (AND)

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

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

   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> new_takeWhile1(vz3100, vz3000, vz3000, vz3100)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, 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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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_primPlusNat(Main.Succ(x0))
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> new_takeWhile1(vz3100, vz3000, vz3000, vz3100) 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(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, 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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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_primPlusNat(Main.Succ(x0))
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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_primPlusNat(Main.Succ(x0))
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz220)) -> Main.Succ(vz220)
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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_primPlusNat(Main.Succ(x0))
   new_psMyInt
   new_psMyInt0(Main.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz220)) -> Main.Succ(vz220)
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100)) 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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) 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(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22))))) 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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, 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(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22) 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(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22))))) 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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))

*(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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))

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




*new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

*(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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)

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




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

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




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

*(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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz220)) -> Main.Succ(vz220)
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100)) 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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) 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(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22))))) 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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, 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(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22) 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(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22))))) 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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))

*(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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))

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




*new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

*(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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)

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




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

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




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

*(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(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
The following pairs are in P_bound:
   new_takeWhile(Main.Pos(Main.Succ(vz3100)), Main.Pos(Main.Succ(vz3000))) -> H(vz3100, vz3000, anew_new_takeWhile1(vz3000, vz3100))
The following rules are usable:
   new_new_takeWhile1(vz230, vz240) -> anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240))
   Main.Zero -> new_primPlusNat(Main.Zero)
   Main.Succ(vz220) -> new_primPlusNat(Main.Succ(vz220))
   new_new_takeWhile1(vz230, vz240) -> new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240))
   cons_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> new_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240))
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Succ(vz240)) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))
   H(vz21, vz22, cons_new_takeWhile1(Main.Zero, Main.Zero)) -> new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero)
   new_takeWhile1(vz21, vz22, Main.Zero, Main.Zero) -> new_takeWhile10(vz21, vz22)
   new_takeWhile10(vz21, vz22) -> new_takeWhile(Main.Pos(Main.Succ(vz21)), Main.Pos(Main.Succ(Main.Succ(new_primPlusNat(vz22)))))

The TRS R consists of the following rules:

   new_primPlusNat(Main.Zero) -> Main.Zero
   new_primPlusNat(Main.Succ(vz220)) -> Main.Succ(vz220)
   anew_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Succ(vz230), Main.Succ(vz240)) -> new_new_takeWhile1(vz230, vz240)
   new_new_takeWhile1(Main.Zero, Main.Succ(vz240)) -> cons_new_takeWhile1(Main.Zero, Main.Succ(vz240))
   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.Succ(x0))
   new_primPlusNat(Main.Zero)
   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(vz21, vz22, Main.Succ(vz230), Main.Succ(vz240)) -> new_takeWhile1(vz21, vz22, vz230, vz240)

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(vz21, vz22, Main.Succ(vz230), Main.Succ(vz240)) -> new_takeWhile1(vz21, vz22, vz230, vz240)
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(vz310), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile(Main.Pos(vz310), new_psMyInt0(vz3000))

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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(vz310), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile(Main.Pos(vz310), new_psMyInt0(vz3000)) (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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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

(59)
YES

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

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

   new_takeWhile(Main.Neg(Main.Succ(vz3100)), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile11(vz3100, vz3000, new_psMyInt0(vz3000), vz3100, vz3000)
   new_takeWhile11(vz64, vz65, vz66, Main.Zero, Main.Succ(vz680)) -> new_takeWhile(Main.Neg(Main.Succ(vz64)), vz66)
   new_takeWhile11(vz64, vz65, vz66, Main.Succ(vz670), Main.Succ(vz680)) -> new_takeWhile11(vz64, vz65, vz66, vz670, vz680)
   new_takeWhile11(vz64, vz65, vz66, Main.Zero, Main.Zero) -> new_takeWhile12(vz64, vz65, vz66)
   new_takeWhile12(vz64, vz65, vz66) -> new_takeWhile(Main.Neg(Main.Succ(vz64)), vz66)

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(vz220)) -> Main.Succ(vz220)
   new_psMyInt0(Main.Succ(vz30000)) -> Main.Neg(Main.Succ(vz30000))
   new_psMyInt -> Main.Pos(Main.Succ(Main.Zero))

The set Q consists of the following terms:

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

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(vz64, vz65, vz66, Main.Zero, Main.Succ(vz680)) -> new_takeWhile(Main.Neg(Main.Succ(vz64)), vz66) (allowed arguments on rhs = {1, 2})
The graph contains the following edges 3 >= 2


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


*new_takeWhile(Main.Neg(Main.Succ(vz3100)), Main.Neg(Main.Succ(vz3000))) -> new_takeWhile11(vz3100, vz3000, new_psMyInt0(vz3000), vz3100, vz3000) (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(vz64, vz65, vz66, Main.Succ(vz670), Main.Succ(vz680)) -> new_takeWhile11(vz64, vz65, vz66, vz670, vz680) (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(vz64, vz65, vz66, Main.Zero, Main.Zero) -> new_takeWhile12(vz64, vz65, vz66) (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(vz30000)) -> Main.Neg(Main.Succ(vz30000))

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

(62)
YES