diff --git a/src/edit.c b/src/edit.c
index 9a0abf9..6ac6142 100644
--- a/src/edit.c
+++ b/src/edit.c
@@ -1763,9 +1763,9 @@
     static void
 undisplay_dollar()
 {
-    if (dollar_vcol)
+    if (dollar_vcol >= 0)
     {
-	dollar_vcol = 0;
+	dollar_vcol = -1;
 	redrawWinline(curwin->w_cursor.lnum, FALSE);
     }
 }
@@ -5441,7 +5441,7 @@
 				compl_curr_match->cp_number);
 		edit_submode_extra = match_ref;
 		edit_submode_highl = HLF_R;
-		if (dollar_vcol)
+		if (dollar_vcol >= 0)
 		    curs_columns(FALSE);
 	    }
 	}
@@ -8961,7 +8961,7 @@
      * We can emulate the vi behaviour by pretending there is a dollar
      * displayed even when there isn't.
      *  --pkv Sun Jan 19 01:56:40 EST 2003 */
-    if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == 0)
+    if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == -1)
 	dollar_vcol = curwin->w_virtcol;
 
 #ifdef FEAT_FOLDING
diff --git a/src/globals.h b/src/globals.h
index 2c7f257..1385192 100644
--- a/src/globals.h
+++ b/src/globals.h
@@ -113,9 +113,9 @@
  * When '$' is included in 'cpoptions' option set:
  * When a change command is given that deletes only part of a line, a dollar
  * is put at the end of the changed text. dollar_vcol is set to the virtual
- * column of this '$'.
+ * column of this '$'.  -1 is used to indicate no $ is being displayed.
  */
-EXTERN colnr_T	dollar_vcol INIT(= 0);
+EXTERN colnr_T	dollar_vcol INIT(= -1);
 
 #ifdef FEAT_INS_EXPAND
 /*
diff --git a/src/move.c b/src/move.c
index f922da8..ccbb4ad 100644
--- a/src/move.c
+++ b/src/move.c
@@ -362,7 +362,7 @@
 #endif
 	    )
     {
-	dollar_vcol = 0;
+	dollar_vcol = -1;
 	if (curwin->w_skipcol != 0)
 	{
 	    curwin->w_skipcol = 0;
@@ -966,7 +966,7 @@
 
     /* remove '$' from change command when cursor moves onto it */
     if (startcol > dollar_vcol)
-	dollar_vcol = 0;
+	dollar_vcol = -1;
 
     extra = curwin_col_off();
     curwin->w_wcol = curwin->w_virtcol + extra;
diff --git a/src/screen.c b/src/screen.c
index ffbd1c3..9bac8bc 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -1637,11 +1637,11 @@
 	     * When at start of changed lines: May scroll following lines
 	     * up or down to minimize redrawing.
 	     * Don't do this when the change continues until the end.
-	     * Don't scroll when dollar_vcol is non-zero, keep the "$".
+	     * Don't scroll when dollar_vcol >= 0, keep the "$".
 	     */
 	    if (lnum == mod_top
 		    && mod_bot != MAXLNUM
-		    && !(dollar_vcol != 0 && mod_bot == mod_top + 1))
+		    && !(dollar_vcol >= 0 && mod_bot == mod_top + 1))
 	    {
 		int		old_rows = 0;
 		int		new_rows = 0;
@@ -1868,12 +1868,12 @@
 	    if (row > wp->w_height)	/* past end of screen */
 	    {
 		/* we may need the size of that too long line later on */
-		if (dollar_vcol == 0)
+		if (dollar_vcol == -1)
 		    wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE);
 		++idx;
 		break;
 	    }
-	    if (dollar_vcol == 0)
+	    if (dollar_vcol == -1)
 		wp->w_lines[idx].wl_size = row - srow;
 	    ++idx;
 #ifdef FEAT_FOLDING
@@ -1990,7 +1990,7 @@
 	    }
 #endif
 	}
-	else if (dollar_vcol == 0)
+	else if (dollar_vcol == -1)
 	    wp->w_botline = lnum;
 
 	/* make sure the rest of the screen is blank */
@@ -2005,7 +2005,7 @@
     wp->w_old_botfill = wp->w_botfill;
 #endif
 
-    if (dollar_vcol == 0)
+    if (dollar_vcol == -1)
     {
 	/*
 	 * There is a trick with w_botline.  If we invalidate it on each
@@ -3564,7 +3564,7 @@
 	}
 
 	/* When still displaying '$' of change command, stop at cursor */
-	if (dollar_vcol != 0 && wp == curwin
+	if (dollar_vcol >= 0 && wp == curwin
 		   && lnum == wp->w_cursor.lnum && vcol >= (long)wp->w_virtcol
 #ifdef FEAT_DIFF
 				   && filler_todo <= 0
diff --git a/src/search.c b/src/search.c
index b29551d..59de988 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2501,8 +2501,8 @@
 	    save_siso = p_siso;
 	    /* Handle "$" in 'cpo': If the ')' is typed on top of the "$",
 	     * stop displaying the "$". */
-	    if (dollar_vcol > 0 && dollar_vcol == curwin->w_virtcol)
-		dollar_vcol = 0;
+	    if (dollar_vcol >= 0 && dollar_vcol == curwin->w_virtcol)
+		dollar_vcol = -1;
 	    ++curwin->w_virtcol;	/* do display ')' just before "$" */
 	    update_screen(VALID);	/* show the new char first */
 
diff --git a/src/version.c b/src/version.c
index a63b67c..a55888f 100644
--- a/src/version.c
+++ b/src/version.c
@@ -715,6 +715,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    426,
+/**/
     425,
 /**/
     424,
