diff --git a/src/mark.c b/src/mark.c
index 5efda8e..6107c9a 100644
--- a/src/mark.c
+++ b/src/mark.c
@@ -140,9 +140,6 @@
     int		i;
     xfmark_T	*fm;
 #endif
-#ifdef JUMPLIST_ROTATE
-    xfmark_T	tempmark;
-#endif
 
     // for :global the mark is set only once
     if (global_busy || listcmd_busy || (cmdmod.cmod_flags & CMOD_KEEPJUMPS))
@@ -152,24 +149,6 @@
     curwin->w_pcmark = curwin->w_cursor;
 
 #ifdef FEAT_JUMPLIST
-# ifdef JUMPLIST_ROTATE
-    /*
-     * If last used entry is not at the top, put it at the top by rotating
-     * the stack until it is (the newer entries will be at the bottom).
-     * Keep one entry (the last used one) at the top.
-     */
-    if (curwin->w_jumplistidx < curwin->w_jumplistlen)
-	++curwin->w_jumplistidx;
-    while (curwin->w_jumplistidx < curwin->w_jumplistlen)
-    {
-	tempmark = curwin->w_jumplist[curwin->w_jumplistlen - 1];
-	for (i = curwin->w_jumplistlen - 1; i > 0; --i)
-	    curwin->w_jumplist[i] = curwin->w_jumplist[i - 1];
-	curwin->w_jumplist[0] = tempmark;
-	++curwin->w_jumplistidx;
-    }
-# endif
-
     // If jumplist is full: remove oldest entry
     if (++curwin->w_jumplistlen > JUMPLISTSIZE)
     {
diff --git a/src/version.c b/src/version.c
index 5153086..0602b9d 100644
--- a/src/version.c
+++ b/src/version.c
@@ -751,6 +751,8 @@
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    2407,
+/**/
     2406,
 /**/
     2405,
