Goal:
    z : Z  z0 : Z  k : t  H : Some (Z.max z z0) = k
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
destruct (Z.max_spec z z0)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
intuition congruence
DEBUG LTAC Evaluated term: (Z.max_spec z z0)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
congruence

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.intuition_then> t

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun tac =>
             <Coq.Init.Tauto.with_uniform_flags>
              ltac:(fun flags => <Coq.Init.Tauto.intuition_gen> flags tac)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.with_uniform_flags>
            ltac:(fun flags => <Coq.Init.Tauto.intuition_gen> flags tac)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun f => <coq-core.plugins.tauto::with_uniform_flags@0>

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun flags => <Coq.Init.Tauto.intuition_gen> flags tac

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<coq-core.plugins.tauto::with_uniform_flags@0>

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
f x
Level 2: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := congruence
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 2: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := congruence
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 1: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := congruence
     of type
     tacvalue
of type
tacvalue of type tacvalue

Level 1: evaluation returns
<coq-core.plugins.tauto::with_uniform_flags@0>
where
f := fun flags => <Coq.Init.Tauto.intuition_gen> flags tac
     where
     tac := congruence
     of type
     tacvalue
of type
tacvalue of type tacvalue


Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.intuition_gen> flags tac

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun flags solver =>
             <Coq.Init.Tauto.tauto_intuit> flags
              ltac:(<Coq.Init.Tauto.reduction_not_iff>) solver

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.tauto_intuit> flags
            ltac:(<Coq.Init.Tauto.reduction_not_iff>) solver

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun flags t_reduce t_solver =>
             let rec t_tauto_intuit :=
              <Coq.Init.Tauto.simplif> flags;
               <Coq.Init.Tauto.axioms> flags ||
                 match reverse goal with
                 | id:(?X1 -> ?X2) -> ?X3
                   |- _ =>
                       Ltac.cut X3;
                        [ intro; clear id; t_tauto_intuit
                        | Ltac.cut (X1 -> X2);
                           [ exact
                           id
                           | generalize (fun y : X2 => id (fun x : X1 => y));
                              intro; clear id; (solve 
                              [ t_tauto_intuit ]) ] ]
                 | id:~ ?X1 -> ?X3
                   |- _ =>
                       Ltac.cut X3;
                        [ intro; clear id; t_tauto_intuit
                        | Ltac.cut (~ X1);
                           [ exact
                           id
                           | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
                 | |- ?X1 =>
                       <Coq.Init.Tauto.is_disj> flags X1; (solve
                        [ Ltac.left; t_tauto_intuit
                        | Ltac.right; t_tauto_intuit ])
                 end ||
                   match goal with
                   | |- _ -> _ => intro; t_tauto_intuit
                   | |- _ => t_reduce; t_solver
                   end || t_solver
             in
             t_tauto_intuit

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun => <coq-core.plugins.tauto::reduction_not_iff@0>

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
let rec t_tauto_intuit :=
            <Coq.Init.Tauto.simplif> flags;
             <Coq.Init.Tauto.axioms> flags ||
               match reverse goal with
               | id:(?X1 -> ?X2) -> ?X3
                 |- _ =>
                     Ltac.cut X3;
                      [ intro; clear id; t_tauto_intuit
                      | Ltac.cut (X1 -> X2);
                         [ exact
                         id
                         | generalize (fun y : X2 => id (fun x : X1 => y));
                            intro; clear id; (solve 
                            [ t_tauto_intuit ]) ] ]
               | id:~ ?X1 -> ?X3
                 |- _ =>
                     Ltac.cut X3;
                      [ intro; clear id; t_tauto_intuit
                      | Ltac.cut (~ X1);
                         [ exact
                         id
                         | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
               | |- ?X1 =>
                     <Coq.Init.Tauto.is_disj> flags X1; (solve
                      [ Ltac.left; t_tauto_intuit
                      | Ltac.right; t_tauto_intuit ])
               end ||
                 match goal with
                 | |- _ -> _ => intro; t_tauto_intuit
                 | |- _ => t_reduce; t_solver
                 end || t_solver
           in
           t_tauto_intuit

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
t_tauto_intuit

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags;
            <Coq.Init.Tauto.axioms> flags ||
              match reverse goal with
              | id:(?X1 -> ?X2) -> ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (X1 -> X2);
                        [ exact
                        id
                        | generalize (fun y : X2 => id (fun x : X1 => y));
                           intro; clear id; (solve 
                           [ t_tauto_intuit ]) ] ]
              | id:~ ?X1 -> ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (~ X1);
                        [ exact
                        id
                        | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
              | |- ?X1 =>
                    <Coq.Init.Tauto.is_disj> flags X1; (solve
                     [ Ltac.left; t_tauto_intuit
                     | Ltac.right; t_tauto_intuit ])
              end ||
                match goal with
                | |- _ -> _ => intro; t_tauto_intuit
                | |- _ => t_reduce; t_solver
                end || t_solver

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags;
            <Coq.Init.Tauto.axioms> flags ||
              match reverse goal with
              | id:(?X1 -> ?X2) -> ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (X1 -> X2);
                        [ exact
                        id
                        | generalize (fun y : X2 => id (fun x : X1 => y));
                           intro; clear id; (solve 
                           [ t_tauto_intuit ]) ] ]
              | id:~ ?X1 -> ?X3
                |- _ =>
                    Ltac.cut X3;
                     [ intro; clear id; t_tauto_intuit
                     | Ltac.cut (~ X1);
                        [ exact
                        id
                        | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
              | |- ?X1 =>
                    <Coq.Init.Tauto.is_disj> flags X1; (solve
                     [ Ltac.left; t_tauto_intuit
                     | Ltac.right; t_tauto_intuit ])
              end ||
                match goal with
                | |- _ -> _ => intro; t_tauto_intuit
                | |- _ => t_reduce; t_solver
                end || t_solver

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.simplif> flags
Level 3: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 3: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 2: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 2: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.simplif> flags;
 <Coq.Init.Tauto.axioms> flags ||
   match reverse goal with
   | id:(?X1 -> ?X2) -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (X1 -> X2);
             [ exact
             id
             | generalize (fun y : X2 => id (fun x : X1 => y)); intro; clear
                id; (solve [ t_tauto_intuit ]) ] ]
   | id:~ ?X1 -> ?X3
     |- _ =>
         Ltac.cut X3;
          [ intro; clear id; t_tauto_intuit
          | Ltac.cut (~ X1);
             [ exact id | clear id; intro; (solve [ t_tauto_intuit ]) ] ]
   | |- ?X1 =>
         <Coq.Init.Tauto.is_disj> flags X1; (solve
          [ Ltac.left; t_tauto_intuit | Ltac.right; t_tauto_intuit ])
   end ||
     match goal with
     | |- _ -> _ => intro; t_tauto_intuit
     | |- _ => t_reduce; t_solver
     end || t_solver
where
t_tauto_intuit := <tactic closure>
of type
tacvalue
t_solver := congruence
of type
tacvalue
t_reduce := <coq-core.plugins.tauto::reduction_not_iff@0>
of type
tacvalue
flags := 
of type
tauto_flags of type tacvalue


Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
fun flags =>
             <Coq.Init.Tauto.not_dep_intros>;
              repeat
               (match reverse goal with
                | id:?X1
                  |- _ =>
                      <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro;
                       clear id
                | id:_ <-> _ |- _ => elim id; do 2 intro; clear id
                | id:~ _ |- _ => red in id
                | id:?X1
                  |- _ =>
                      <Coq.Init.Tauto.is_disj> flags X1; elim id; intro;
                       clear id
                | _ =>
                    <Coq.Init.Tauto.find_cut>
                     ltac:(fun id0 id1 X2 =>
                             assert X2; [ exact (id0 id1) | clear id0 ])
                | id:?X1 -> ?X2
                  |- _ =>
                      <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
                       [ intro; clear id
                       | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
                | id:?X1 -> ?X2
                  |- _ =>
                      <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2
                       id
                | id:?X1 <-> ?X2 -> ?X3
                  |- _ =>
                      assert ((X1 -> X2) -> (X2 -> X1) -> X3) by
                       (do 2 intro; apply id; Ltac.split; Ltac.assumption);
                       clear id
                | id:?X1 -> ?X2
                  |- _ =>
                      <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2
                       id
                | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
                | |- _ <-> _ => Ltac.split
                | |- ~ _ => red
                end; <Coq.Init.Tauto.not_dep_intros>)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.not_dep_intros>;
            repeat
             (match reverse goal with
              | id:?X1
                |- _ =>
                    <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro;
                     clear id
              | id:_ <-> _ |- _ => elim id; do 2 intro; clear id
              | id:~ _ |- _ => red in id
              | id:?X1
                |- _ =>
                    <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear
                     id
              | _ =>
                  <Coq.Init.Tauto.find_cut>
                   ltac:(fun id0 id1 X2 =>
                           assert X2; [ exact (id0 id1) | clear id0 ])
              | id:?X1 -> ?X2
                |- _ =>
                    <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
                     [ intro; clear id
                     | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
              | id:?X1 -> ?X2
                |- _ =>
                    <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2
                     id
              | id:?X1 <-> ?X2 -> ?X3
                |- _ =>
                    assert ((X1 -> X2) -> (X2 -> X1) -> X3) by
                     (do 2 intro; apply id; Ltac.split; Ltac.assumption);
                     clear id
              | id:?X1 -> ?X2
                |- _ =>
                    <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2
                     id
              | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
              | |- _ <-> _ => Ltac.split
              | |- ~ _ => red
              end; <Coq.Init.Tauto.not_dep_intros>)

Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
<Coq.Init.Tauto.not_dep_intros>
Level 1: evaluation returns
<Coq.Init.Tauto.not_dep_intros>;
 repeat
  (match reverse goal with
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro; clear id
   | id:_ <-> _ |- _ => elim id; do 2 intro; clear id
   | id:~ _ |- _ => red in id
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear id
   | _ =>
       <Coq.Init.Tauto.find_cut>
        ltac:(fun id0 id1 X2 => assert X2; [ exact (id0 id1) | clear id0 ])
   | id:?X1 -> ?X2
     |- _ =>
         <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
          [ intro; clear id
          | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
   | id:?X1 -> ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2 id
   | id:?X1 <-> ?X2 -> ?X3
     |- _ =>
         assert ((X1 -> X2) -> (X2 -> X1) -> X3) by
          (do 2 intro; apply id; Ltac.split; Ltac.assumption); clear id
   | id:?X1 -> ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2 id
   | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
   | |- _ <-> _ => Ltac.split
   | |- ~ _ => red
   end; <Coq.Init.Tauto.not_dep_intros>)
where
flags := 
of type
tauto_flags of type tacvalue

Level 1: evaluation returns
<Coq.Init.Tauto.not_dep_intros>;
 repeat
  (match reverse goal with
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_conj> flags X1; elim id; do 2 intro; clear id
   | id:_ <-> _ |- _ => elim id; do 2 intro; clear id
   | id:~ _ |- _ => red in id
   | id:?X1
     |- _ => <Coq.Init.Tauto.is_disj> flags X1; elim id; intro; clear id
   | _ =>
       <Coq.Init.Tauto.find_cut>
        ltac:(fun id0 id1 X2 => assert X2; [ exact (id0 id1) | clear id0 ])
   | id:?X1 -> ?X2
     |- _ =>
         <Coq.Init.Tauto.is_unit_or_eq> flags X1; Ltac.cut X2;
          [ intro; clear id
          | Ltac.cut X1; [ exact id | constructor 1; fail ] ]
   | id:?X1 -> ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_conj> flags X1 X2 id
   | id:?X1 <-> ?X2 -> ?X3
     |- _ =>
         assert ((X1 -> X2) -> (X2 -> X1) -> X3) by
          (do 2 intro; apply id; Ltac.split; Ltac.assumption); clear id
   | id:?X1 -> ?X2
     |- _ => <Coq.Init.Tauto.flatten_contravariant_disj> flags X1 X2 id
   | |- ?X1 => <Coq.Init.Tauto.is_conj> flags X1; Ltac.split
   | |- _ <-> _ => Ltac.split
   | |- ~ _ => red
   end; <Coq.Init.Tauto.not_dep_intros>)
where
flags := 
of type
tauto_flags of type tacvalue


Goals:
  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z < z0)%Z /\ Z.max z z0 = z0
  ============================
   (Some z = k \/ Some z0 = k)

  
  z : Z
  z0 : Z
  k : t
  H : Some (Z.max z z0) = k
  H0 : (z0 <= z)%Z /\ Z.max z z0 = z
  ============================
   (Some z = k \/ Some z0 = k)


DEBUG:Going to execute:
repeat
            match goal with
            | |- ?X1 -> ?X2 => intro
            | |- ~ _ => unfold not at 1; intro
            end