Goal:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  ============================
   (forall (m1 : tree' A) (m2 : tree' B) (i : positive),
    get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))


DEBUG:Going to execute:
induction m1

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node001 m1) m2) =
    f (get' i (Node001 m1)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node010 a) m2) =
    f (get' i (Node010 a)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node011 a m1) m2) =
    f (get' i (Node011 a m1)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node100 m1) m2) =
    f (get' i (Node100 m1)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node101 m1_1 m1_2) m2) =
    f (get' i (Node101 m1_1 m1_2)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node110 m1 a) m2) =
    f (get' i (Node110 m1 a)) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  ============================
   (forall (m2 : tree' B) (i : positive),
    get i (combine'_by_tac (Node111 m1_1 a m1_2) m2) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i m2))


DEBUG:Going to execute:
destruct m2

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node001 m2)) =
    f (get' i (Node001 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node010 b)) =
    f (get' i (Node001 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node011 b m2)) =
    f (get' i (Node001 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node100 m2)) =
    f (get' i (Node001 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node110 m2 b)) =
    f (get' i (Node001 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node001 m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node001 m2)) =
    f (get' i (Node010 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node010 b)) =
    f (get' i (Node010 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node011 b m2)) =
    f (get' i (Node010 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node100 m2)) =
    f (get' i (Node010 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node101 m2_1 m2_2)) =
    f (get' i (Node010 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node110 m2 b)) =
    f (get' i (Node010 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node010 a) (Node111 m2_1 b m2_2)) =
    f (get' i (Node010 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node001 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node010 b)) =
    f (get' i (Node011 a m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node011 b m2)) =
    f (get' i (Node011 a m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node100 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node110 m2 b)) =
    f (get' i (Node011 a m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node011 a m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node001 m2)) =
    f (get' i (Node100 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node010 b)) =
    f (get' i (Node100 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node011 b m2)) =
    f (get' i (Node100 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node100 m2)) =
    f (get' i (Node100 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node110 m2 b)) =
    f (get' i (Node100 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node100 m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node001 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node010 b)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node011 b m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node100 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node101 m2_1 m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node110 m2 b)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node101 m1_1 m1_2) (Node111 m2_1 b m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node001 m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node010 b)) =
    f (get' i (Node110 m1 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node011 b m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node100 m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node101 m2_1 m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node110 m2 b)) =
    f (get' i (Node110 m1 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node110 m1 a) (Node111 m2_1 b m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node001 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node010 b)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node011 b m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node100 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node101 m2_1 m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node110 m2 b)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (forall i : positive,
    get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node111 m2_1 b m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node111 m2_1 b m2_2)))


DEBUG:Going to execute:
intros

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node001 m2)) =
    f (get' i (Node001 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node010 b)) =
    f (get' i (Node001 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node011 b m2)) =
    f (get' i (Node001 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node100 m2)) =
    f (get' i (Node001 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node110 m2 b)) =
    f (get' i (Node001 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node001 m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node001 m2)) =
    f (get' i (Node010 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node010 b)) =
    f (get' i (Node010 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node011 b m2)) =
    f (get' i (Node010 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node100 m2)) =
    f (get' i (Node010 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node101 m2_1 m2_2)) =
    f (get' i (Node010 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node110 m2 b)) =
    f (get' i (Node010 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node010 a) (Node111 m2_1 b m2_2)) =
    f (get' i (Node010 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node001 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node010 b)) =
    f (get' i (Node011 a m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node011 b m2)) =
    f (get' i (Node011 a m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node100 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node110 m2 b)) =
    f (get' i (Node011 a m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node011 a m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node001 m2)) =
    f (get' i (Node100 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node010 b)) =
    f (get' i (Node100 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node011 b m2)) =
    f (get' i (Node100 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node100 m2)) =
    f (get' i (Node100 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node101 m2_1 m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node110 m2 b)) =
    f (get' i (Node100 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node100 m1) (Node111 m2_1 b m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node001 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node010 b)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node011 b m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node100 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node101 m2_1 m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node110 m2 b)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node101 m1_1 m1_2) (Node111 m2_1 b m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node001 m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node010 b)) =
    f (get' i (Node110 m1 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node011 b m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node100 m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node101 m2_1 m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node110 m2 b)) =
    f (get' i (Node110 m1 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node110 m1 a) (Node111 m2_1 b m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node001 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node010 b)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node011 b m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node100 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node101 m2_1 m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node110 m2 b)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac (Node111 m1_1 a m1_2) (Node111 m2_1 b m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node111 m2_1 b m2_2)))


DEBUG:Going to execute:
simpl

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty None (combine'_by_tac m1 m2)) =
    f (get' i (Node001 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node Empty (f None (Some b)) (combine'_l m1)) =
    f (get' i (Node001 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty (f None (Some b)) (combine'_by_tac m1 m2)) =
    f (get' i (Node001 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2) None (combine'_l m1)) =
    f (get' i (Node001 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2_1) None (combine'_by_tac m1 m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (Node (combine'_r m2) (f None (Some b)) (combine'_l m1)) =
    f (get' i (Node001 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_r m2_1) (f None (Some b)) (combine'_by_tac m1 m2_2)) =
    f (get' i (Node001 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) None) (combine'_r m2)) =
    f (get' i (Node010 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) (Some b)) Empty) =
    f (get' i (Node010 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) (Some b)) (combine'_r m2)) =
    f (get' i (Node010 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2) (f (Some a) None) Empty) =
    f (get' i (Node010 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2_1) (f (Some a) None) (combine'_r m2_2)) =
    f (get' i (Node010 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (Node (combine'_r m2) (f (Some a) (Some b)) Empty) =
    f (get' i (Node010 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2_1) (f (Some a) (Some b)) (combine'_r m2_2)) =
    f (get' i (Node010 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) None) (combine'_by_tac m1 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) (Some b)) (combine'_l m1)) =
    f (get' i (Node011 a m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (Node Empty (f (Some a) (Some b)) (combine'_by_tac m1 m2)) =
    f (get' i (Node011 a m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_r m2) (f (Some a) None) (combine'_l m1)) =
    f (get' i (Node011 a m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_r m2_1) (f (Some a) None) (combine'_by_tac m1 m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (Node (combine'_r m2) (f (Some a) (Some b)) (combine'_l m1)) =
    f (get' i (Node011 a m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_r m2_1) (f (Some a) (Some b)) (combine'_by_tac m1 m2_2)) =
    f (get' i (Node011 a m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_l m1) None (combine'_r m2)) =
    f (get' i (Node100 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node (combine'_l m1) (f None (Some b)) Empty) =
    f (get' i (Node100 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_l m1) (f None (Some b)) (combine'_r m2)) =
    f (get' i (Node100 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1 m2) None Empty) =
    f (get' i (Node100 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1 m2_1) None (combine'_r m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1 m2) (f None (Some b)) Empty) =
    f (get' i (Node100 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1 m2_1) (f None (Some b)) (combine'_r m2_2)) =
    f (get' i (Node100 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_l m1_1) None (combine'_by_tac m1_2 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node (combine'_l m1_1) (f None (Some b)) (combine'_l m1_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_l m1_1) (f None (Some b)) (combine'_by_tac m1_2 m2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1_1 m2) None (combine'_l m1_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1_1 m2_1) None (combine'_by_tac m1_2 m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2) (f None (Some b)) (combine'_l m1_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2_1) (f None (Some b))
         (combine'_by_tac m1_2 m2_2)) =
    f (get' i (Node101 m1_1 m1_2)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_l m1) (f (Some a) None) (combine'_r m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node (combine'_l m1) (f (Some a) (Some b)) Empty) =
    f (get' i (Node110 m1 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_l m1) (f (Some a) (Some b)) (combine'_r m2)) =
    f (get' i (Node110 m1 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1 m2) (f (Some a) None) Empty) =
    f (get' i (Node110 m1 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1 m2_1) (f (Some a) None) (combine'_r m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (Node (combine'_by_tac m1 m2) (f (Some a) (Some b)) Empty) =
    f (get' i (Node110 m1 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1 m2_1) (f (Some a) (Some b)) (combine'_r m2_2)) =
    f (get' i (Node110 m1 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_l m1_1) (f (Some a) None) (combine'_by_tac m1_2 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (Node (combine'_l m1_1) (f (Some a) (Some b)) (combine'_l m1_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_l m1_1) (f (Some a) (Some b)) (combine'_by_tac m1_2 m2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2) (f (Some a) None) (combine'_l m1_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2_1) (f (Some a) None)
         (combine'_by_tac m1_2 m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2) (f (Some a) (Some b)) (combine'_l m1_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i
      (Node (combine'_by_tac m1_1 m2_1) (f (Some a) (Some b))
         (combine'_by_tac m1_2 m2_2)) =
    f (get' i (Node111 m1_1 a m1_2)) (get' i (Node111 m2_1 b m2_2)))


DEBUG:Going to execute:
rewrite gNode

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2)
    | xO j => get j Empty
    | xH => None
    end = f (get' i (Node001 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j Empty
    | xH => f None (Some b)
    end = f (get' i (Node001 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2)
    | xO j => get j Empty
    | xH => f None (Some b)
    end = f (get' i (Node001 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j (combine'_r m2)
    | xH => None
    end = f (get' i (Node001 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => None
    end = f (get' i (Node001 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j (combine'_r m2)
    | xH => f None (Some b)
    end = f (get' i (Node001 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => f None (Some b)
    end = f (get' i (Node001 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j Empty
    | xH => f (Some a) None
    end = f (get' i (Node010 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (match i with
    | xI j | xO j => get j Empty
    | xH => f (Some a) (Some b)
    end = f (get' i (Node010 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j Empty
    | xH => f (Some a) (Some b)
    end = f (get' i (Node010 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_r m2)
    | xH => f (Some a) None
    end = f (get' i (Node010 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => f (Some a) None
    end = f (get' i (Node010 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_r m2)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node010 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node010 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2)
    | xO j => get j Empty
    | xH => f (Some a) None
    end = f (get' i (Node011 a m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j Empty
    | xH => f (Some a) (Some b)
    end = f (get' i (Node011 a m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2)
    | xO j => get j Empty
    | xH => f (Some a) (Some b)
    end = f (get' i (Node011 a m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j (combine'_r m2)
    | xH => f (Some a) None
    end = f (get' i (Node011 a m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => f (Some a) None
    end = f (get' i (Node011 a m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1)
    | xO j => get j (combine'_r m2)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node011 a m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1 m2_2)
    | xO j => get j (combine'_r m2_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node011 a m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j (combine'_l m1)
    | xH => None
    end = f (get' i (Node100 m1)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_l m1)
    | xH => f None (Some b)
    end = f (get' i (Node100 m1)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j (combine'_l m1)
    | xH => f None (Some b)
    end = f (get' i (Node100 m1)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_by_tac m1 m2)
    | xH => None
    end = f (get' i (Node100 m1)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_by_tac m1 m2_1)
    | xH => None
    end = f (get' i (Node100 m1)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_by_tac m1 m2)
    | xH => f None (Some b)
    end = f (get' i (Node100 m1)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_by_tac m1 m2_1)
    | xH => f None (Some b)
    end = f (get' i (Node100 m1)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2)
    | xO j => get j (combine'_l m1_1)
    | xH => None
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_l m1_1)
    | xH => f None (Some b)
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2)
    | xO j => get j (combine'_l m1_1)
    | xH => f None (Some b)
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_by_tac m1_1 m2)
    | xH => None
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2_2)
    | xO j => get j (combine'_by_tac m1_1 m2_1)
    | xH => None
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_by_tac m1_1 m2)
    | xH => f None (Some b)
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2_2)
    | xO j => get j (combine'_by_tac m1_1 m2_1)
    | xH => f None (Some b)
    end = f (get' i (Node101 m1_1 m1_2)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j (combine'_l m1)
    | xH => f (Some a) None
    end = f (get' i (Node110 m1 a)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_l m1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node110 m1 a)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2)
    | xO j => get j (combine'_l m1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node110 m1 a)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_by_tac m1 m2)
    | xH => f (Some a) None
    end = f (get' i (Node110 m1 a)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_by_tac m1 m2_1)
    | xH => f (Some a) None
    end = f (get' i (Node110 m1 a)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j Empty
    | xO j => get j (combine'_by_tac m1 m2)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node110 m1 a)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_r m2_2)
    | xO j => get j (combine'_by_tac m1 m2_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node110 m1 a)) (get' i (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2)
    | xO j => get j (combine'_l m1_1)
    | xH => f (Some a) None
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_l m1_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2)
    | xO j => get j (combine'_l m1_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_by_tac m1_1 m2)
    | xH => f (Some a) None
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2_2)
    | xO j => get j (combine'_by_tac m1_1 m2_1)
    | xH => f (Some a) None
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_l m1_2)
    | xO j => get j (combine'_by_tac m1_1 m2)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (match i with
    | xI j => get j (combine'_by_tac m1_2 m2_2)
    | xO j => get j (combine'_by_tac m1_1 m2_1)
    | xH => f (Some a) (Some b)
    end = f (get' i (Node111 m1_1 a m1_2)) (get' i (Node111 m2_1 b m2_2)))


DEBUG:Going to execute:
destruct i
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode
DEBUG LTAC Evaluated term: gNode

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node001 m1)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node001 m1)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node001 m1)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f (get' xH (Node001 m1)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node001 m1)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) = f (get' xH (Node001 m1)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node001 m1)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node001 m1)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node001 m1)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f (get' xH (Node001 m1)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node001 m1)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) = f (get' xH (Node001 m1)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) =
    f (get' (xI i) (Node001 m1)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node001 m1)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) =
    f (get' xH (Node001 m1)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node010 a)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node010 a)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node010 a)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node010 a)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node010 a)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node010 a)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node010 a)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node010 a)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node010 a)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node010 a)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node010 a)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node010 a)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node010 a)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node010 a)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node010 a)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node010 a)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node010 a)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node010 a)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node010 a)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node010 a)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node010 a)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node011 a m1)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node011 a m1)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node011 a m1)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node011 a m1)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None =
    f (get' xH (Node011 a m1)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node011 a m1)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) =
    f (get' (xI i) (Node011 a m1)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) =
    f (get' (xO i) (Node011 a m1)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node011 a m1)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node100 m1)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node100 m1)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node100 m1)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f (get' xH (Node100 m1)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node100 m1)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) = f (get' xH (Node100 m1)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node100 m1)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node100 m1)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node100 m1)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f (get' xH (Node100 m1)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node100 m1)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) = f (get' xH (Node100 m1)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node100 m1)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) =
    f (get' (xO i) (Node100 m1)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) =
    f (get' xH (Node100 m1)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) =
    f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (None = f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) =
    f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) =
    f (get' (xI i) (Node101 m1_1 m1_2)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) =
    f (get' (xO i) (Node101 m1_1 m1_2)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) =
    f (get' xH (Node101 m1_1 m1_2)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node110 m1 a)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node110 m1 a)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) =
    f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node110 m1 a)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (get' xH (Node110 m1 a)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None =
    f (get' xH (Node110 m1 a)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i Empty = f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (get' xH (Node110 m1 a)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) =
    f (get' (xI i) (Node110 m1 a)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) =
    f (get' (xO i) (Node110 m1 a)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node110 m1 a)) (get' xH (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node001 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node010 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node011 b m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node100 m2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node101 m2_1 m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node110 m2 b)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) =
    f (get' (xI i) (Node111 m1_1 a m1_2)) (get' (xI i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) =
    f (get' (xO i) (Node111 m1_1 a m1_2)) (get' (xO i) (Node111 m2_1 b m2_2)))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) =
    f (get' xH (Node111 m1_1 a m1_2)) (get' xH (Node111 m2_1 b m2_2)))


DEBUG:Going to execute:
simpl
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i
DEBUG LTAC Evaluated term: i

Goals:
  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) = f (get' i m1) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) = f (get' i m1) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) = f (get' i m1) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_2) = f (get' i m1) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_1) = f None (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  a : A
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) = f (get' i m1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) = f (get' i m1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) = f (get' i m1_2) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) = f (get' i m1_1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) = f (get' i m1_2) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) = f (get' i m1_1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f None (Some b) = f None (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2) = f None (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1) = f (get' i m1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) = f (get' i m1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (None = f None None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_r m2_2) = f None (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1 m2_1) = f (get' i m1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1 : tree' A
  a : A
  IHm1 : forall (m2 : tree' B) (i : positive),
         get i (combine'_by_tac m1 m2) = f (get' i m1) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_1) = f (get' i m1_1) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  b : B
  m2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) = f (get' i m1_2) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) = f (get' i m1_1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  m2_2 : tree' B
  ============================
   (f (Some a) None = f (Some a) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_l m1_2) = f (get' i m1_2) None)

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2 : tree' B
  b : B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_2 m2_2) = f (get' i m1_2) (get' i m2_2))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  i : positive
  ============================
   (get i (combine'_by_tac m1_1 m2_1) = f (get' i m1_1) (get' i m2_1))

  
  A : Type
  B : Type
  C : Type
  f : option A -> option B -> option C
  f_None_None : f None None = None
  m1_1 : tree' A
  a : A
  m1_2 : tree' A
  IHm1_1 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_1 m2) = f (get' i m1_1) (get' i m2)
  IHm1_2 : forall (m2 : tree' B) (i : positive),
           get i (combine'_by_tac m1_2 m2) = f (get' i m1_2) (get' i m2)
  m2_1 : tree' B
  b : B
  m2_2 : tree' B
  ============================
   (f (Some a) (Some b) = f (Some a) (Some b))


DEBUG:Going to execute:
auto using gcombine'_l, gcombine'_r