Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java	(revision 30782)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapAction.java	(revision 30783)
@@ -186,6 +186,5 @@
             combine.add(way);
             for (Way opositWay : ways) {
-                if (way != opositWay
-                        && way.getNodesCount() == opositWay.getNodesCount()) {
+                if (way != opositWay && way.getNodesCount() == opositWay.getNodesCount()) {
                     boolean equals1 = true;
                     for (int i = 0; i < way.getNodesCount(); i++) {
@@ -197,7 +196,5 @@
                     boolean equals2 = true;
                     for (int i = 0; i < way.getNodesCount(); i++) {
-                        if (way.getNode(i) != opositWay.getNode(way
-                                .getNodesCount()
-                                - i - 1)) {
+                        if (way.getNode(i) != opositWay.getNode(way.getNodesCount() - i - 1)) {
                             equals2 = false;
                             break;
@@ -283,6 +280,5 @@
     private boolean follows(Way way1, Way way2, NodePos np1, NodePos np2,
             int incr) {
-        if (way2.isClosed() && incr == 1
-                && np1.opositPos == way2.getNodesCount() - 2) {
+        if (way2.isClosed() && incr == 1 && np1.opositPos == way2.getNodesCount() - 2) {
             return np2.pos == np1.pos + 1 && np2.opositPos == 0;
         } else if (way2.isClosed() && incr == 1 && np1.opositPos == 0) {
@@ -290,10 +286,8 @@
                     || np2.pos == np1.pos + 1 && np2.opositPos == 1;
         } else if (way2.isClosed() && incr == -1 && np1.opositPos == 0) {
-            return np2.pos == np1.pos && np2.opositPos == 0
-                    || np2.pos == np1.pos + 1
+            return np2.pos == np1.pos && np2.opositPos == 0 || np2.pos == np1.pos + 1
                     && np2.opositPos == way2.getNodesCount() - 2;
         } else {
-            return np2.pos == np1.pos + 1
-                    && np2.opositPos == np1.opositPos + incr;
+            return np2.pos == np1.pos + 1 && np2.opositPos == np1.opositPos + incr;
         }
     }
@@ -307,14 +301,11 @@
      * @return
      */
-    private SplitWayResult splitWay(OsmDataLayer layer, Way way,
-            List<List<Node>> wayChunks) {
+    private SplitWayResult splitWay(OsmDataLayer layer, Way way, List<List<Node>> wayChunks) {
         // build a list of commands, and also a new selection list
-        Collection<Command> commandList = new ArrayList<>(wayChunks
-                .size());
+        Collection<Command> commandList = new ArrayList<>(wayChunks.size());
 
         Iterator<List<Node>> chunkIt = wayChunks.iterator();
-        Collection<String> nowarnroles = Main.pref.getCollection(
-                "way.split.roles.nowarn", Arrays.asList(new String[] { "outer",
-                        "inner", "forward", "backward" }));
+        Collection<String> nowarnroles = Main.pref.getCollection("way.split.roles.nowarn",
+                Arrays.asList(new String[] { "outer", "inner", "forward", "backward" }));
 
         // First, change the original way
@@ -402,6 +393,5 @@
                             warnme = true;
                         }
-                    } else if (!("route".equals(type))
-                            && !("multipolygon".equals(type))) {
+                    } else if (!("route".equals(type)) && !("multipolygon".equals(type))) {
                         warnme = true;
                     }
@@ -418,24 +408,18 @@
                         int k = 1;
                         while (ir - k >= 0 || ir + k < relationMembers.size()) {
-                            if ((ir - k >= 0)
-                                    && relationMembers.get(ir - k).isWay()) {
+                            if ((ir - k >= 0) && relationMembers.get(ir - k).isWay()) {
                                 Way w = relationMembers.get(ir - k).getWay();
-                                if ((w.lastNode() == way.firstNode())
-                                        || w.firstNode() == way.firstNode()) {
+                                if ((w.lastNode() == way.firstNode()) || w.firstNode() == way.firstNode()) {
                                     backwards = false;
-                                } else if ((w.firstNode() == way.lastNode())
-                                        || w.lastNode() == way.lastNode()) {
+                                } else if ((w.firstNode() == way.lastNode()) || w.lastNode() == way.lastNode()) {
                                     backwards = true;
                                 }
                                 break;
                             }
-                            if ((ir + k < relationMembers.size())
-                                    && relationMembers.get(ir + k).isWay()) {
+                            if ((ir + k < relationMembers.size()) && relationMembers.get(ir + k).isWay()) {
                                 Way w = relationMembers.get(ir + k).getWay();
-                                if ((w.lastNode() == way.firstNode())
-                                        || w.firstNode() == way.firstNode()) {
+                                if ((w.lastNode() == way.firstNode()) || w.firstNode() == way.firstNode()) {
                                     backwards = true;
-                                } else if ((w.firstNode() == way.lastNode())
-                                        || w.lastNode() == way.lastNode()) {
+                                } else if ((w.firstNode() == way.lastNode()) || w.lastNode() == way.lastNode()) {
                                     backwards = false;
                                 }
@@ -447,6 +431,5 @@
                         int j = ic;
                         for (Way wayToAdd : newWays) {
-                            RelationMember em = new RelationMember(
-                                    rm.getRole(), wayToAdd);
+                            RelationMember em = new RelationMember(rm.getRole(), wayToAdd);
                             j++;
                             if ((backwards != null) && backwards) {
@@ -469,18 +452,14 @@
         }
         if (warnmerole) {
-            JOptionPane.showMessageDialog(
-                Main.parent,
+            JOptionPane.showMessageDialog(Main.parent,
                 tr("<html>A role based relation membership was copied to all new ways.<br>You should verify this and correct it when necessary.</html>"),
                 tr("Warning"), JOptionPane.WARNING_MESSAGE);
         } else if (warnme) {
-            JOptionPane.showMessageDialog(
-                Main.parent,
+            JOptionPane.showMessageDialog(Main.parent,
                 tr("<html>A relation membership was copied to all new ways.<br>You should verify this and correct it when necessary.</html>"),
                 tr("Warning"), JOptionPane.WARNING_MESSAGE);
         }
 
-        return new SplitWayResult(
-                new SequenceCommand(tr("Split way"), commandList), null,
-                changedWay, newWays);
+        return new SplitWayResult(new SequenceCommand(tr("Split way"), commandList), null, changedWay, newWays);
     }
 
@@ -491,12 +470,10 @@
      * @throws UserCancelException
      */
-    private Pair<Way, List<Command>> combineWaysWorker(Collection<Way> ways)
-            throws UserCancelException {
+    private Pair<Way, List<Command>> combineWaysWorker(Collection<Way> ways) throws UserCancelException {
 
         // prepare and clean the list of ways to combine
         if (ways == null || ways.isEmpty())
             return null;
-        ways.remove(null); // just in case - remove all null ways from the
-                            // collection
+        ways.remove(null); // just in case - remove all null ways from the collection
 
         // remove duplicates, preserving order
@@ -514,6 +491,5 @@
         List<Way> unreversedWays = new LinkedList<>();
         for (Way w : ways) {
-            if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w
-                    .getNode(1))) {
+            if ((path.indexOf(w.getNode(0)) + 1) == path.lastIndexOf(w.getNode(1))) {
                 unreversedWays.add(w);
             } else {
@@ -529,8 +505,6 @@
         if ((reversedWays != null) && !reversedWays.isEmpty()) {
             // filter out ways that have no direction-dependent tags
-            unreversedWays = ReverseWayTagCorrector
-                    .irreversibleWays(unreversedWays);
-            reversedWays = ReverseWayTagCorrector
-                    .irreversibleWays(reversedWays);
+            unreversedWays = ReverseWayTagCorrector.irreversibleWays(unreversedWays);
+            reversedWays = ReverseWayTagCorrector.irreversibleWays(reversedWays);
             // reverse path if there are more reversed than unreversed ways with
             // direction-dependent tags
@@ -552,9 +526,7 @@
                     Way wnew = new Way(w);
                     reversedTagWays.add(wnew);
-                    changePropertyCommands = reverseWayTagCorrector.execute(w,
-                            wnew);
-                }
-                if ((changePropertyCommands != null)
-                        && !changePropertyCommands.isEmpty()) {
+                    changePropertyCommands = reverseWayTagCorrector.execute(w, wnew);
+                }
+                if ((changePropertyCommands != null) && !changePropertyCommands.isEmpty()) {
                     for (Command c : changePropertyCommands) {
                         c.executeCommand();