Goal:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  n : nat
  l : list A
  l' : list B
  l'' : list C
  ============================
   (All2i P n l l'
    → All2 Q l' l''
      → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
        → All2 R l' l'')


DEBUG:Going to execute:
induction 1 in l'' |- *

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  ============================
   (All2 Q [] l''
    → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
      → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  ============================
   (All2 Q (y :: r) l''
    → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
      → All2 R (y :: r) l'')


DEBUG:Going to execute:
intros H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
depelim H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun H => DepElim.depelim H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.depelim H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun id =>
             DepElim.do_depelim ltac:(fun hyp => DepElim.do_case hyp) id

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_depelim ltac:(fun hyp => DepElim.do_case hyp) id

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun tac H =>
             DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
              CoreTactics.unblock_goal

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun hyp => DepElim.do_case hyp

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
            CoreTactics.unblock_goal

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim
Level 3: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 3: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 2: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 2: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 1: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 1: evaluation returns
DepElim.do_depelim_nosimpl tac H; DepElim.simpl_dep_elim;
 CoreTactics.unblock_goal
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue


Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_depelim_nosimpl tac H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun tac H =>
             DepElim.do_intros H; DepElim.generalize_by_eqs H; tac H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_intros H; DepElim.generalize_by_eqs H; tac H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_intros H; DepElim.generalize_by_eqs H
Level 1: evaluation returns
DepElim.do_intros H; DepElim.generalize_by_eqs H; tac H
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue

Level 1: evaluation returns
DepElim.do_intros H; DepElim.generalize_by_eqs H; tac H
where
tac := fun hyp => DepElim.do_case hyp
       where
       id := H
       of type
       ident
of type
tacvalue
H := H
of type
ident of type tacvalue


Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
DepElim.do_intros H

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
fun H =>
             try intros until H; intro_block_id H || intro_block H;
              (try simpl in H; DepElim.simplify_equations_in H)

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
try intros until H; intro_block_id H || intro_block H;
            (try simpl in H; DepElim.simplify_equations_in H)

Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
try intros until H; intro_block_id H || intro_block H
Level 1: evaluation returns
try intros until H; intro_block_id H || intro_block H;
 (try simpl in H; DepElim.simplify_equations_in H)
where
H := H
of type
ident of type tacvalue

Level 1: evaluation returns
try intros until H; intro_block_id H || intro_block H;
 (try simpl in H; DepElim.simplify_equations_in H)
where
H := H
of type
ident of type tacvalue


Goals:
  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  H : All2 Q [] l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R [] l'')

  
  A : Type
  B : Type
  C : Type
  P : nat → A → B → Type
  Q : B → C → Type
  R : B → C → Type
  l'' : list C
  n : nat
  x : A
  y : B
  l : list A
  r : list B
  r0 : P n x y
  X : All2i P (S n) l r
  IHX : ∀ l'' : list C,
          All2 Q r l''
          → (∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
            → All2 R r l''
  H : All2 Q (y :: r) l''
  ============================
   ((∀ (n : nat) (x : A) (y : B) (z : C), P n x y → Q y z → R y z)
    → All2 R (y :: r) l'')


DEBUG:Going to execute:
try intros until H