diff --git a/Nevanlinna/firstMain.lean b/Nevanlinna/firstMain.lean
index 46fb339..bc3aa81 100644
--- a/Nevanlinna/firstMain.lean
+++ b/Nevanlinna/firstMain.lean
@@ -45,24 +45,36 @@ theorem Nevanlinna_counting₁₁
   (hf : MeromorphicOn f ⊤) :
   (hf.add (MeromorphicOn.const a)).N_infty = hf.N_infty := by
 
-  have {z : ℂ} : 0 < (hf z trivial).order → (hf z trivial).order = ((hf.add (MeromorphicOn.const a)) z trivial).order:= by
-    intro h
-
-    let A := (MeromorphicAt.const a)
-    rw [←MeromorphicAt.order_add_of_ne_orders (hf z trivial)]
-    simp
-    sorry
-
   funext r
   unfold MeromorphicOn.N_infty
   let A := (hf.restrict |r|).divisor.finiteSupport (isCompact_closedBall 0 |r|)
   repeat
     rw [finsum_eq_sum_of_support_subset (s := A.toFinset)]
   apply Finset.sum_congr rfl
-  intro x hx
+  intro x hx; simp at hx
   congr 2
-  
-  simp at hx
+
+  by_cases h : 0 ≤ (hf.restrict |r|).divisor x
+  · simp [h]
+    let A := (hf.restrict |r|).divisor_add_const₁ a h
+    exact A
+
+  · simp at h
+    have h' : 0 ≤ -((hf.restrict |r|).divisor x) := by
+      apply Int.le_neg_of_le_neg
+      simp
+      exact Int.le_of_lt h
+    simp [h']
+    clear h'
+
+
+
+
+    simp [h]
+
+    linarith
+
+
 
   sorry
 
diff --git a/Nevanlinna/meromorphicAt.lean b/Nevanlinna/meromorphicAt.lean
index fdd9fab..f8f2d05 100644
--- a/Nevanlinna/meromorphicAt.lean
+++ b/Nevanlinna/meromorphicAt.lean
@@ -11,7 +11,7 @@ theorem meromorphicAt_congr
   {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
   {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
   {f : 𝕜 → E} {g : 𝕜 → E} {x : 𝕜}
-  (h : f =ᶠ[nhdsWithin x {x}ᶜ] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
+  (h : f =ᶠ[𝓝[≠] x] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
   ⟨fun hf ↦ hf.congr h, fun hg ↦ hg.congr h.symm⟩
 
 
@@ -455,4 +455,38 @@ theorem MeromorphicAt.order_add_of_ne_orders
   rw [this, h₃g]
   simp
 
+-- Might want to think about adding an analytic function instead of a constant
+theorem MeromorphicAt.order_add_const
+  --have {z : ℂ} : 0 < (hf z trivial).order → (hf z trivial).order = ((hf.add (MeromorphicOn.const a)) z trivial).order:= by
+  {f : ℂ → ℂ}
+  {z a : ℂ}
+  (hf : MeromorphicAt f z) :
+  hf.order < 0 → hf.order = (hf.add (MeromorphicAt.const a z)).order := by
+  intro h
+
+  by_cases ha: a = 0
+  · -- might want theorem MeromorphicAt.order_const
+    have : (MeromorphicAt.const a z).order = ⊤ := by
+      rw [MeromorphicAt.order_eq_top_iff]
+      rw [ha]
+      simp
+    rw [←hf.order_add_of_ne_orders (MeromorphicAt.const a z)]
+    rw [this]
+    simp
+    rw [this]
+    exact LT.lt.ne_top h
+  · have : (MeromorphicAt.const a z).order = (0 : ℤ) := by
+      rw [MeromorphicAt.order_eq_int_iff]
+      use fun _ ↦ a
+      constructor
+      · exact analyticAt_const
+      · simpa
+    rw [←hf.order_add_of_ne_orders (MeromorphicAt.const a z)]
+    rw [this]
+    simp
+    exact le_of_lt h
+    rw [this]
+    exact ne_of_lt h
+
+
 -- might want theorem MeromorphicAt.order_zpow
diff --git a/Nevanlinna/meromorphicOn_divisor.lean b/Nevanlinna/meromorphicOn_divisor.lean
index 3a0bcbd..9429fa8 100644
--- a/Nevanlinna/meromorphicOn_divisor.lean
+++ b/Nevanlinna/meromorphicOn_divisor.lean
@@ -169,6 +169,61 @@ theorem MeromorphicOn.divisor_inv
     simp [hz]
 
 
+theorem MeromorphicOn.divisor_add_const₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (a : ℂ) :
+  0 ≤ hf.divisor z → 0 ≤ (hf.add (MeromorphicOn.const a)).divisor z := by
+  intro h
+
+  unfold MeromorphicOn.divisor
+
+  -- Trivial case: z ∉ U
+  by_cases hz : z ∉ U
+  · simp [hz]
+
+  -- Non-trivial case: z ∈ U
+  simp at hz; simp [hz]
+
+  by_cases h₁f : (hf z hz).order = ⊤
+  · have : f + (fun z ↦ a) =ᶠ[𝓝[≠] z] (fun z ↦ a) := by
+      rw [MeromorphicAt.order_eq_top_iff] at h₁f
+      rw [eventually_nhdsWithin_iff] at h₁f
+      rw [eventually_nhds_iff] at h₁f
+      obtain ⟨t, ht⟩ := h₁f
+      rw [eventuallyEq_nhdsWithin_iff]
+      rw [eventually_nhds_iff]
+      use t
+      simp [ht]
+      tauto
+    rw [((hf z hz).add (MeromorphicAt.const a z)).order_congr this]
+
+    by_cases ha: (MeromorphicAt.const a z).order = ⊤
+    · simp [ha]
+    · rw [WithTop.le_untop'_iff]
+      apply AnalyticAt.meromorphicAt_order_nonneg
+      exact analyticAt_const
+      tauto
+
+  · rw [WithTop.le_untop'_iff]
+    let A := (hf z hz).order_add (MeromorphicAt.const a z)
+    have : 0 ≤ min (hf z hz).order (MeromorphicAt.const a z).order := by
+      apply le_min
+      --
+      unfold MeromorphicOn.divisor at h
+      simp [hz] at h
+      let V := untop'_of_ne_top (d := 0) h₁f
+      rw [← V]
+      simp [h]
+      --
+      apply AnalyticAt.meromorphicAt_order_nonneg
+      exact analyticAt_const
+    exact le_trans this A
+    tauto
+
+
 theorem MeromorphicOn.divisor_of_makeStronglyMeromorphicOn
   {f : ℂ → ℂ}
   {U : Set ℂ}