diff --git a/fcore/cursor.sml b/fcore/cursor.sml
index 4b7eaeb..665e2f5 100644
--- a/fcore/cursor.sml
+++ b/fcore/cursor.sml
@@ -126,6 +126,30 @@ struct
           cursorIdx
     end
 
+  fun helpViL (strIdx, hd, cursorIdx, tl) =
+    if String.sub (hd, strIdx) = #"\n" then
+      (* if line break, go to next idx, no matter what chr is there *)
+      cursorIdx + 1
+    else
+      if strIdx + 1 < String.size hd then
+        (* next chr is in hd *)
+        if String.sub (hd, strIdx + 1) = #"\n" then
+          (* if non-line break followed by line break, go to chr + 2 *)
+          cursorIdx + 2
+        else
+          cursorIdx + 1
+      else
+        (case tl of
+          tlhd :: _ =>
+            if String.sub (tlhd, 0) = #"\n" then
+              (* non-line break followed by line break *)
+              cursorIdx + 2
+            else
+              (* non-line break followed by non-line break *)
+              cursorIdx
+        | [] => 
+            cursorIdx)
+
   (* Prerequisite: lineGap is moved to requested idx first 
    * todo: check if we are in a \r\n pair, but this is not a priority *)
   fun viL (lineGap: LineGap.t, cursorIdx) =
@@ -138,58 +162,20 @@ struct
             (* convert absolute cursorIdx to idx relative to hd string *)
             val strIdx = cursorIdx - bufferIdx
           in
-            if strIdx + 1 < String.size hd then
-              (* if there is at least one character after this idx *)
-              let
-                val nextChr = String.sub (hd, strIdx + 1)
-              in
-                (case nextChr of
-                   #"\n" =>
-                     if strIdx + 2 < String.size hd then
-                       (* if there are at least two chars after strIdx *)
-                       cursorIdx + 2
-                     else
-                       (* only one char after strIdx which is \n 
-                        * if there is a string at the tl, can increment by 2 *)
-                       (case tl of
-                          _ :: _ => cursorIdx + 2
-                        | [] => cursorIdx + 1)
-                 | _ => cursorIdx + 1)
-              end
+            if strIdx < String.size hd then
+              (* strIdx is in hd *)
+              helpViL (strIdx, hd, cursorIdx, tl)
             else
-              (* no chars after this idx; have to check tl *)
+              (* strIdx is in tl *)
               (case tl of
-                 tlhd :: tltl =>
-                   (* if there is another string after current head, we can increment cursorIdx 
-                    * however, first we need to check if next char is \n. *)
-                   let
-                     val nextChr = String.sub (tlhd, 0)
-                   in
-                     (case nextChr of
-                        #"\n" =>
-                          if String.size tlhd > 2 then
-                            (* if there is at least one character after \n 
-                             * then increment cursorIdx by 2 *)
-                            cursorIdx + 2
-                          else
-                            (* this string only contains \n
-                             * but there is a small possibility tltl
-                             * contains another string.
-                             * If it does, we can increment cursorIdx by 2,
-                             * moving past newline.
-                             * If not, increment cursorIdx by 1,
-                             * landing on newline. *)
-                            (case tltl of
-                               _ :: _ => cursorIdx + 2
-                             | [] => cursorIdx + 1)
-                      | _ =>
-                          (* next char is not newline, 
-                           * so we can just increment by 1 *)
-                          cursorIdx + 1)
-                   end
-               | [] =>
-                   (* if there is no string after current head, return original cursorIdx *)
-                   cursorIdx)
+                tlhd :: tltl =>
+                  let
+                    val strIdx = strIdx - String.size hd
+                  in
+                    helpViL (strIdx, tlhd, cursorIdx, tltl)
+                  end
+              | [] => 
+                  cursorIdx)
           end
       | [] =>
           (* return original cursorIdx if there is nothing to the right *)
diff --git a/temp.txt b/temp.txt
index cc99065..b2794ba 100644
--- a/temp.txt
+++ b/temp.txt
@@ -5,6 +5,8 @@ sig
              -> MailboxType.t list
 end
 
+
+
 structure TextBuilder :> TEXT_BUILDER =
 struct
   val xSpace = 13