From d5b9d54314b0b004691c73da7c26cc2759711bc9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jindra=20Pet=C5=99=C3=ADk?= <jindra.petrik@gmail.com>
Date: Sat, 14 Feb 2026 18:49:28 +0100
Subject: [PATCH] Debugging in the browser, improved

---
 .../flash/gui/BreakpointListDialog.java       |    6 +-
 .../decompiler/flash/gui/DebugPanel.java      |   92 +-
 .../decompiler/flash/gui/DebugStackPanel.java |   47 +-
 .../decompiler/flash/gui/DebuggerHandler.java | 1251 ++---------------
 .../decompiler/flash/gui/DebuggerSession.java | 1176 ++++++++++++++++
 src/com/jpexs/decompiler/flash/gui/Main.java  |  325 +++--
 .../decompiler/flash/gui/MainFrameMenu.java   |   20 +-
 .../jpexs/decompiler/flash/gui/MainPanel.java |   32 +-
 .../decompiler/flash/gui/abc/ABCPanel.java    |   15 +-
 .../decompiler/flash/gui/abc/DetailPanel.java |    8 +-
 .../flash/gui/action/ActionPanel.java         |    8 +-
 .../gui/editor/DebuggableEditorPane.java      |    2 +-
 12 files changed, 1674 insertions(+), 1308 deletions(-)
 create mode 100644 src/com/jpexs/decompiler/flash/gui/DebuggerSession.java

diff --git a/src/com/jpexs/decompiler/flash/gui/BreakpointListDialog.java b/src/com/jpexs/decompiler/flash/gui/BreakpointListDialog.java
index 8c8e53009..dfaf82bb2 100644
--- a/src/com/jpexs/decompiler/flash/gui/BreakpointListDialog.java
+++ b/src/com/jpexs/decompiler/flash/gui/BreakpointListDialog.java
@@ -197,16 +197,16 @@ public class BreakpointListDialog extends AppDialog {
         defaultTableModel.addColumn(translate("breakpoint.line"));
         defaultTableModel.addColumn(translate("breakpoint.status"));
 
-        Map<String, Set<Integer>> breakpoints = Main.getDebugHandler().getAllBreakPoints(swf, false);
+        Map<String, Set<Integer>> breakpoints = Main.getDebugHandler().getAllSessionsBreakPoints(swf);
 
         List<Breakpoint> newBreakpointList = new ArrayList<>();
         for (String scriptName : breakpoints.keySet()) {
             for (int line : breakpoints.get(scriptName)) {
                 newBreakpointList.add(new Breakpoint(scriptName, line));
                 String status = "unknown";
-                if (Main.getDebugHandler().isBreakpointInvalid(swf, scriptName, line)) {
+                if (Main.getCurrentDebugSession().isBreakpointInvalid(swf, scriptName, line)) {
                     status = "invalid";
-                } else if (Main.getDebugHandler().isBreakpointConfirmed(swf, scriptName, line)) {
+                } else if (Main.getCurrentDebugSession().isBreakpointConfirmed(swf, scriptName, line)) {
                     status = "confirmed";
                 }
                 defaultTableModel.addRow(new Object[]{scriptName, line, translate("breakpoint.status." + status)});
diff --git a/src/com/jpexs/decompiler/flash/gui/DebugPanel.java b/src/com/jpexs/decompiler/flash/gui/DebugPanel.java
index 8a484c6f0..2a7abfd4b 100644
--- a/src/com/jpexs/decompiler/flash/gui/DebugPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/DebugPanel.java
@@ -36,6 +36,7 @@ import java.awt.event.MouseEvent;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -89,6 +90,8 @@ public class DebugPanel extends JPanel {
     private boolean loading = false;
 
     public ABCPanel.VariablesTableModel localsTable;
+    
+    private WeakReference<DebuggerSession> currentSessionRef = null;
 
     public static enum SelectedTab {
 
@@ -140,7 +143,7 @@ public class DebugPanel extends JPanel {
 
     }
 
-    private void logAdd(String message) {
+    private void logAdd(DebuggerSession session, String message) {
         boolean wasEmpty = logLength == 0;
         String add = message + "\r\n";
         logLength += add.length();
@@ -151,7 +154,7 @@ public class DebugPanel extends JPanel {
             //ignore
         }
         if (wasEmpty) {
-            refresh();
+            refresh(session);
         }
     }
 
@@ -177,6 +180,15 @@ public class DebugPanel extends JPanel {
             }
 
             private void dopop(MouseEvent e) {
+                
+                if (currentSessionRef == null) {
+                    return;
+                }
+                DebuggerSession session = currentSessionRef.get();
+                if (session == null) {
+                    return;
+                }
+                
                 if (debugLocalsTable.getSelectedRow() == -1) {
                     return;
                 }
@@ -241,8 +253,8 @@ public class DebugPanel extends JPanel {
                             }*/
                             //Variant using comma separated bytes, pretty fast
                             try {
-                                Variable debugConnectionClass = Main.getDebugHandler().getVariable(0, Main.currentDebuggerPackage + "::DebugConnection", false, false).parent;
-                                String dataStr = (String) Main.getDebugHandler().callMethod(debugConnectionClass, "readCommaSeparatedFromByteArray", Arrays.asList(v)).variables.get(0).value;
+                                Variable debugConnectionClass = session.getVariable(0, Main.currentDebuggerPackage + "::DebugConnection", false, false).parent;
+                                String dataStr = (String) session.callMethod(debugConnectionClass, "readCommaSeparatedFromByteArray", Arrays.asList(v)).variables.get(0).value;
                                 String[] parts = dataStr.split(",");
                                 byte[] data = new byte[parts.length];
                                 for (int i = 0; i < parts.length; i++) {
@@ -313,9 +325,9 @@ public class DebugPanel extends JPanel {
                                     splitter = ",";
                                 }
                                 String dataStr = sb.toString();
-                                Variable debugConnectionClass = Main.getDebugHandler().getVariable(0, Main.currentDebuggerPackage + "::DebugConnection", false, false).parent;
+                                Variable debugConnectionClass = session.getVariable(0, Main.currentDebuggerPackage + "::DebugConnection", false, false).parent;
                                 try {
-                                    Main.getDebugHandler().callMethod(debugConnectionClass, "writeCommaSeparatedToByteArray", Arrays.asList(dataStr, v));
+                                    session.callMethod(debugConnectionClass, "writeCommaSeparatedToByteArray", Arrays.asList(dataStr, v));
                                 } catch (DebuggerHandler.ActionScriptException ex) {
                                     Logger.getLogger(DebugPanel.class.getName()).log(Level.SEVERE, "Error exporting ByteArray", ex);
                                 }
@@ -334,19 +346,19 @@ public class DebugPanel extends JPanel {
                 JMenu addWatchMenu = new JMenu(AppStrings.translate("debug.watch.add").replace("%name%", v.name));
                 JMenuItem watchReadMenuItem = new JMenuItem(AppStrings.translate("debug.watch.add.read"));
                 watchReadMenuItem.addActionListener((ActionEvent e1) -> {
-                    if (!Main.addWatch(v, watchParentId, true, false)) {
+                    if (!Main.addWatch(session, v, watchParentId, true, false)) {
                         ViewMessages.showMessageDialog(DebugPanel.this, AppStrings.translate("error.debug.watch.add"), AppStrings.translate("error"), JOptionPane.ERROR_MESSAGE);
                     }
                 });
                 JMenuItem watchWriteMenuItem = new JMenuItem(AppStrings.translate("debug.watch.add.write"));
                 watchWriteMenuItem.addActionListener((ActionEvent e1) -> {
-                    if (!Main.addWatch(v, watchParentId, false, true)) {
+                    if (!Main.addWatch(session, v, watchParentId, false, true)) {
                         ViewMessages.showMessageDialog(DebugPanel.this, AppStrings.translate("error.debug.watch.add"), AppStrings.translate("error"), JOptionPane.ERROR_MESSAGE);
                     }
                 });
                 JMenuItem watchReadWriteMenuItem = new JMenuItem(AppStrings.translate("debug.watch.add.readwrite"));
                 watchReadWriteMenuItem.addActionListener((ActionEvent e1) -> {
-                    if (!Main.addWatch(v, watchParentId, true, true)) {
+                    if (!Main.addWatch(session, v, watchParentId, true, true)) {
                         ViewMessages.showMessageDialog(DebugPanel.this, AppStrings.translate("error.debug.watch.add"), AppStrings.translate("error"), JOptionPane.ERROR_MESSAGE);
                     }
                 });
@@ -376,41 +388,41 @@ public class DebugPanel extends JPanel {
         Main.getDebugHandler().addTraceListener(new DebuggerHandler.TraceListener() {
 
             @Override
-            public void trace(String... val) {
+            public void trace(DebuggerSession session, String... val) {
                 for (String s : val) {
-                    logAdd("trace: " + s);
+                    logAdd(session, "trace: " + s);
                 }
             }
         });
 
         Main.getDebugHandler().addErrorListener(new DebuggerHandler.ErrorListener() {
             @Override
-            public void errorException(String message, Variable thrownVar) {
-                logAdd("unhandled exception: " + message);
+            public void errorException(DebuggerSession session, String message, Variable thrownVar) {
+                logAdd(session, "unhandled exception: " + message);
                 selectedTab = tabTypes.get(tabTypes.size() - 1);
-                refresh();
+                refresh(session);
             }
         });
 
         Main.getDebugHandler().addConnectionListener(new DebuggerHandler.ConnectionListener() {
 
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
             }
 
             @Override
-            public void disconnected() {
-                refresh();
+            public void disconnected(DebuggerSession session) {
+                refresh(session);
             }
         });
 
         Main.getDebugHandler().addFrameChangeListener(frameChangeListener = new DebuggerHandler.FrameChangeListener() {
             @Override
-            public void frameChanged() {
+            public void frameChanged(DebuggerSession session) {
                 View.execInEventDispatchLater(new Runnable() {
                     @Override
                     public void run() {
-                        refresh();
+                        refresh(session);
                     }
                 });
             }
@@ -419,17 +431,17 @@ public class DebugPanel extends JPanel {
         Main.getDebugHandler().addBreakListener(breakListener = new DebuggerHandler.BreakListener() {
 
             @Override
-            public void doContinue() {
+            public void doContinue(DebuggerSession session) {
                 View.execInEventDispatch(new Runnable() {
                     @Override
                     public void run() {
-                        refresh();
+                        refresh(session);
                     }
                 });
             }
 
             @Override
-            public void breakAt(String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
+            public void breakAt(DebuggerSession session, String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
 
             }
         });
@@ -484,8 +496,9 @@ public class DebugPanel extends JPanel {
         }
         return v.getMembers(this);
     }*/
-    public void refresh() {
-
+    public void refresh(DebuggerSession session) {       
+        
+        currentSessionRef = session == null ? null : new WeakReference<>(session);
         View.execInEventDispatch(new Runnable() {
 
             @Override
@@ -495,19 +508,14 @@ public class DebugPanel extends JPanel {
 
                     SelectedTab oldSel = selectedTab;
                     localsTable = null;
-                    SWF swf = Main.getDebuggedSWF();
-                    if (swf == null) {
-                        return;
-                    }
-                    boolean as3 = swf.isAS3();
-                    InFrame f = Main.getDebugHandler().getFrame();
+                    InFrame f = session == null ? null : session.getFrame();
                     if (f != null) {
                         
                         
                         List<Variable> locals = new ArrayList<>();
                         
                         
-                        Map<String, Long> placedObjects = Main.getDebugHandler().getPlacedObjects();
+                        Map<String, Long> placedObjects = session.getPlacedObjects();
                         for (String poName : placedObjects.keySet()) {
                             String realName = poName;
                             if ("/".equals(realName)) {
@@ -515,7 +523,7 @@ public class DebugPanel extends JPanel {
                             } else if (realName.startsWith("/")) {
                                 continue;
                             }
-                            Variable placedVar = Main.getDebugHandler().getVariable(0, realName, false, false).parent;
+                            Variable placedVar = session.getVariable(0, realName, false, false).parent;
                             if (placedVar != null) {
                                 locals.add(placedVar);
                             }
@@ -540,26 +548,26 @@ public class DebugPanel extends JPanel {
                         TreeModelListener refreshListener = new TreeModelListener() {
                             @Override
                             public void treeNodesChanged(TreeModelEvent e) {
-                                Main.getDebugHandler().refreshFrame();
-                                refresh();
+                                session.refreshFrame();
+                                refresh(session);
                             }
 
                             @Override
                             public void treeNodesInserted(TreeModelEvent e) {
-                                Main.getDebugHandler().refreshFrame();
-                                refresh();
+                                session.refreshFrame();
+                                refresh(session);
                             }
 
                             @Override
                             public void treeNodesRemoved(TreeModelEvent e) {
-                                Main.getDebugHandler().refreshFrame();
-                                refresh();
+                                session.refreshFrame();
+                                refresh(session);
                             }
 
                             @Override
                             public void treeStructureChanged(TreeModelEvent e) {
-                                Main.getDebugHandler().refreshFrame();
-                                refresh();
+                                session.refreshFrame();
+                                refresh(session);
                             }
                         };
                         debugLocalsTable.getTreeTableModel().addTreeModelListener(refreshListener);
@@ -569,7 +577,7 @@ public class DebugPanel extends JPanel {
                         debugLocalsTable.setTreeModel(new ABCPanel.VariablesTableModel(debugLocalsTable, new ArrayList<>()));
                         debugScopeTable.setTreeModel(new ABCPanel.VariablesTableModel(debugScopeTable, new ArrayList<>()));
                     }
-                    InConstantPool cpool = Main.getDebugHandler().getConstantPool();
+                    InConstantPool cpool = session == null ? null : session.getConstantPool();
                     if (cpool != null) {
                         Object[][] data2 = new Object[cpool.vars.size()][2];
                         for (int i = 0; i < cpool.vars.size(); i++) {
@@ -635,7 +643,7 @@ public class DebugPanel extends JPanel {
                             public void actionPerformed(ActionEvent e) {
                                 traceLogTextarea.setText("");
                                 logLength = 0;
-                                refresh();
+                                refresh(session);
                             }
                         });
                         JPanel butPanel = new JPanel(new FlowLayout());
diff --git a/src/com/jpexs/decompiler/flash/gui/DebugStackPanel.java b/src/com/jpexs/decompiler/flash/gui/DebugStackPanel.java
index a63fb9969..f1024602c 100644
--- a/src/com/jpexs/decompiler/flash/gui/DebugStackPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/DebugStackPanel.java
@@ -23,6 +23,7 @@ import java.awt.Component;
 import java.awt.Font;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.lang.ref.WeakReference;
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JTable;
@@ -46,35 +47,40 @@ public class DebugStackPanel extends JPanel {
     private int[] classIndices = new int[0];
     private int[] methodIndices = new int[0];
     private int[] traitIndices = new int[0];
-
+    private WeakReference<DebuggerSession> currentSessionRef = null;
+    
     public DebugStackPanel() {
         stackTable = new JTable();
         Main.getDebugHandler().addFrameChangeListener(new DebuggerHandler.FrameChangeListener() {
             @Override
-            public void frameChanged() {
-                depth = Main.getDebugHandler().getDepth();
-                refresh();
+            public void frameChanged(DebuggerSession session) {
+                if (session == null) {
+                    refresh(null);
+                    return;
+                }
+                depth = session.getDepth();
+                refresh(session);
             }
         });
         Main.getDebugHandler().addBreakListener(new DebuggerHandler.BreakListener() {
             @Override
-            public void breakAt(String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
+            public void breakAt(DebuggerSession session, String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
 
             }
 
             @Override
-            public void doContinue() {
+            public void doContinue(DebuggerSession session) {
                 clear();
             }
         });
 
         Main.getDebugHandler().addConnectionListener(new DebuggerHandler.ConnectionListener() {
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
             }
 
             @Override
-            public void disconnected() {
+            public void disconnected(DebuggerSession session) {
                 clear();
             }
         });
@@ -96,7 +102,13 @@ public class DebugStackPanel extends JPanel {
                         SWF swf = swfHash == null ? Main.getRunningSWF() : Main.getSwfByHash(swfHash);
                         Main.getMainFrame().getPanel().gotoScriptLine(swf,
                                 scriptName, line, classIndices[row], traitIndices[row], methodIndices[row], Main.isDebugPCode());
-                        Main.getDebugHandler().setDepth(row);
+                        DebuggerSession session = null;
+                        if (currentSessionRef != null) {
+                            session = currentSessionRef.get();
+                        }
+                        if (session != null) {
+                            session.setDepth(row);
+                        }
                     }
                 }
             }
@@ -112,8 +124,12 @@ public class DebugStackPanel extends JPanel {
         return active;
     }
 
-    public void refresh() {
-        InBreakAtExt info = Main.getDebugHandler().getBreakInfo();
+    public void refresh(DebuggerSession session) {
+        if (session == null) {
+            clear();
+            return;
+        }
+        InBreakAtExt info = session.getBreakInfo();
         if (info == null) {
             clear();
             return;
@@ -126,7 +142,7 @@ public class DebugStackPanel extends JPanel {
         int[] newTraitIndices = new int[info.files.size()];
         for (int i = 0; i < info.files.size(); i++) {
             int f = info.files.get(i);
-            String moduleName = Main.getDebugHandler().moduleToString(f);
+            String moduleName = session.moduleToString(f);
             String swfHash = null;
             if (moduleName.contains(":")) {
                 swfHash = moduleName.substring(0, moduleName.indexOf(":"));
@@ -137,11 +153,11 @@ public class DebugStackPanel extends JPanel {
             data[i][1] = moduleName;
             data[i][2] = info.lines.get(i);
             data[i][3] = info.stacks.get(i);
-            Integer newClassIndex = Main.getDebugHandler().moduleToClassIndex(f);
+            Integer newClassIndex = session.moduleToClassIndex(f);
             newClassIndices[i] = newClassIndex == null ? -1 : newClassIndex;
-            Integer newMethodIndex = Main.getDebugHandler().moduleToMethodIndex(f);
+            Integer newMethodIndex = session.moduleToMethodIndex(f);
             newMethodIndices[i] = newMethodIndex == null ? -1 : newMethodIndex;
-            Integer newTraitIndex = Main.getDebugHandler().moduleToTraitIndex(f);
+            Integer newTraitIndex = session.moduleToTraitIndex(f);
             ;
             newTraitIndices[i] = newTraitIndex == null ? -1 : newTraitIndex;
         }
@@ -184,6 +200,7 @@ public class DebugStackPanel extends JPanel {
                 repaint();
             }
         });
+        currentSessionRef = new WeakReference<>(session);        
     }
 
     public int getDepth() {
diff --git a/src/com/jpexs/decompiler/flash/gui/DebuggerHandler.java b/src/com/jpexs/decompiler/flash/gui/DebuggerHandler.java
index fa84f362d..fd9ac4972 100644
--- a/src/com/jpexs/decompiler/flash/gui/DebuggerHandler.java
+++ b/src/com/jpexs/decompiler/flash/gui/DebuggerHandler.java
@@ -17,51 +17,13 @@
 package com.jpexs.decompiler.flash.gui;
 
 import com.jpexs.debugger.flash.DebugConnectionListener;
-import com.jpexs.debugger.flash.DebugMessageListener;
 import com.jpexs.debugger.flash.Debugger;
-import com.jpexs.debugger.flash.DebuggerCommands;
 import com.jpexs.debugger.flash.DebuggerConnection;
 import com.jpexs.debugger.flash.Variable;
-import com.jpexs.debugger.flash.VariableFlags;
-import com.jpexs.debugger.flash.VariableType;
-import com.jpexs.debugger.flash.messages.in.InBreakAt;
-import com.jpexs.debugger.flash.messages.in.InBreakAtExt;
-import com.jpexs.debugger.flash.messages.in.InBreakReason;
-import com.jpexs.debugger.flash.messages.in.InCallFunction;
-import com.jpexs.debugger.flash.messages.in.InConstantPool;
-import com.jpexs.debugger.flash.messages.in.InContinue;
-import com.jpexs.debugger.flash.messages.in.InErrorException;
-import com.jpexs.debugger.flash.messages.in.InExit;
-import com.jpexs.debugger.flash.messages.in.InFrame;
-import com.jpexs.debugger.flash.messages.in.InGetSwf;
-import com.jpexs.debugger.flash.messages.in.InGetVariable;
-import com.jpexs.debugger.flash.messages.in.InNumScript;
-import com.jpexs.debugger.flash.messages.in.InPlaceObject;
-import com.jpexs.debugger.flash.messages.in.InProcessTag;
-import com.jpexs.debugger.flash.messages.in.InScript;
-import com.jpexs.debugger.flash.messages.in.InSetBreakpoint;
-import com.jpexs.debugger.flash.messages.in.InSwfInfo;
-import com.jpexs.debugger.flash.messages.in.InTrace;
-import com.jpexs.debugger.flash.messages.in.InVersion;
-import com.jpexs.debugger.flash.messages.out.OutAddWatch2;
-import com.jpexs.debugger.flash.messages.out.OutGetBreakReason;
-import com.jpexs.debugger.flash.messages.out.OutGetSwf;
-import com.jpexs.debugger.flash.messages.out.OutPlay;
-import com.jpexs.debugger.flash.messages.out.OutProcessedTag;
-import com.jpexs.debugger.flash.messages.out.OutRewind;
-import com.jpexs.debugger.flash.messages.out.OutStopDebug;
-import com.jpexs.debugger.flash.messages.out.OutSwfInfo;
 import com.jpexs.decompiler.flash.SWF;
-import com.jpexs.decompiler.flash.configuration.Configuration;
-import com.jpexs.decompiler.graph.DottedChain;
-import com.jpexs.helpers.Helper;
-import java.io.FileOutputStream;
 import java.io.IOException;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -70,59 +32,17 @@ import java.util.Set;
 import java.util.TreeSet;
 import java.util.WeakHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /**
  * @author JPEXS
  */
 public class DebuggerHandler implements DebugConnectionListener {
-    
-    private boolean connected = false;
 
-    private DebuggerCommands commands = null;
+    private List<DebuggerSession> sessions = Collections.synchronizedList(new ArrayList<>());
 
-    //private List<InSwfInfo.SwfInfo> swfs = new ArrayList<>();
-    private boolean paused = true;
+    private boolean terminating = false;
 
-    private Map<Integer, String> modulePaths = new HashMap<>();
-
-    private Map<Integer, Integer> moduleToSwfIndex = new HashMap<>();
-
-    //Marks swfIndices that are fully loaded - at least one break was on it (including onloaded break)
-    private Set<Integer> swfIndicesCommitted = new HashSet<>();
-
-    private Map<Integer, String> swfIndicesNewToSwfHash = new HashMap<>();
-
-    private Map<String, Integer> scriptToModule = new HashMap<>();
-
-    private Map<Integer, Integer> moduleToTraitIndex = new HashMap<>();
-
-    private Map<Integer, Integer> moduleToClassIndex = new HashMap<>();
-
-    private Map<Integer, Integer> moduleToMethodIndex = new HashMap<>();
-
-    private Map<SWF, Map<String, Set<Integer>>> toAddBPointMap = new WeakHashMap<>();
-
-    private Map<SWF, Map<String, Set<Integer>>> confirmedPointMap = new WeakHashMap<>();
-
-    private Map<SWF, Map<String, Set<Integer>>> invalidBreakPointMap = new WeakHashMap<>();
-
-    private Map<SWF, Map<String, Set<Integer>>> toRemoveBPointMap = new WeakHashMap<>();
-
-    private int breakIp = -1;
-
-    private String breakScriptName = null;
-
-    private List<String> stackScriptNames = new ArrayList<>();
-
-    private List<Integer> stackLines = new ArrayList<>();
-
-    private List<SWF> debuggedSwfs = new ArrayList<>();
-    
-    private Map<String, Long> placedObjects = new LinkedHashMap<>();
+    private Map<SWF, Map<String, Set<Integer>>> allBreakPoints = new WeakHashMap<>();
 
     public static class ActionScriptException extends Exception {
 
@@ -142,521 +62,103 @@ public class DebuggerHandler implements DebugConnectionListener {
         }
     }
 
-    public void setMainDebuggedSwf(SWF debuggedSwf) {
-        debuggedSwfs.clear();
-        //debuggedSwfs.add(debuggedSwf);
-    }
-
-    public List<SWF> getDebuggedSwfs() {
-        return debuggedSwfs;
-    }
-
-    public int getBreakIp() {
-        if (!isPaused()) {
-            return -1;
-        }
-        return breakIp;
-    }
-
-    public int getDepth() {
-        return depth;
-    }
-
-    public String getBreakScriptName() {
-        if (!isPaused()) {
-            return "-";
-        }
-        return breakScriptName;
-    }
-
-    public synchronized List<String> getStackScripts() {
-        if (!isPaused()) {
-            return new ArrayList<>();
-        }
-        return stackScriptNames;
-    }
-
-    public synchronized List<Integer> getStackLines() {
-        if (!isPaused()) {
-            return new ArrayList<>();
-        }
-        return stackLines;
-    }
-
-    public InGetVariable getVariable(long parentId, String varName, boolean children, boolean useGetter) {
-        try {
-            return commands.getVariable(parentId, varName, useGetter, children);
-        } catch (IOException ex) {
-            return null;
-        }
-    }
-
-    public void setVariable(long parentId, String varName, int valueType, Object value) {
-        try {
-            String svalue = "";
-            switch (valueType) {
-                case VariableType.STRING:
-                    svalue = "" + value;
-                    break;
-                case VariableType.NUMBER:
-                    svalue = "" + value;
-                    break;
-                case VariableType.BOOLEAN:
-                    svalue = ((Boolean) value) ? "true" : "false";
-                    break;
-                case VariableType.UNDEFINED:
-                    svalue = "undefined";
-                    break;
-                case VariableType.NULL:
-                    svalue = "undefined";
-                    break;
-            }
-            commands.setVariable(parentId, varName, valueType, svalue);
-        } catch (IOException ex) {
-            //ignore
-        }
-    }
-
-    public synchronized void removeBreakPoint(SWF swf, String scriptName, int line) {
-        if (isBreakpointInvalid(swf, scriptName, line)) {
-            invalidBreakPointMap.get(swf).get(scriptName).remove(line);
-            if (invalidBreakPointMap.get(swf).get(scriptName).isEmpty()) {
-                invalidBreakPointMap.get(swf).remove(scriptName);
-            }
-            return;
-        }
-        if (isBreakpointToAdd(swf, scriptName, line)) {
-            toAddBPointMap.get(swf).get(scriptName).remove(line);
-            if (toAddBPointMap.get(swf).get(scriptName).isEmpty()) {
-                toAddBPointMap.get(swf).remove(scriptName);
-            }
-        } else if (isBreakpointConfirmed(swf, scriptName, line)) {
-            if (!toRemoveBPointMap.containsKey(swf)) {
-                toRemoveBPointMap.put(swf, new HashMap<>());
-            }
-            if (!toRemoveBPointMap.get(swf).containsKey(scriptName)) {
-                toRemoveBPointMap.get(swf).put(scriptName, new TreeSet<>());
-            }
-            toRemoveBPointMap.get(swf).get(scriptName).add(line);
-        }
-        try {
-            sendBreakPoints();
-        } catch (IOException ex) {
-            //ignore
-        }
-    }
-
-    private int watchTag = 1;
-
-    public synchronized com.jpexs.debugger.flash.DebuggerCommands.Watch addWatch(Variable v, long v_id, boolean watchRead, boolean watchWrite) {
-        int tag = watchTag++;
-        try {
-            return commands.addWatch(v_id, v.name, (watchRead ? OutAddWatch2.FLAG_READ : 0) | (watchWrite ? OutAddWatch2.FLAG_WRITE : 0), tag);
-        } catch (IOException ex) {
-            return null;
-        }
-    }
-
-    public synchronized Set<Integer> getBreakPoints(SWF swf, String scriptName, boolean onlyValid) {
-        Set<Integer> lines = new TreeSet<>();
-        if (confirmedPointMap.containsKey(swf) && confirmedPointMap.get(swf).containsKey(scriptName)) {
-            lines.addAll(confirmedPointMap.get(swf).get(scriptName));
-        }
-        if (toAddBPointMap.containsKey(swf) && toAddBPointMap.get(swf).containsKey(scriptName)) {
-            lines.addAll(toAddBPointMap.get(swf).get(scriptName));
-        }
-        if (!onlyValid && invalidBreakPointMap.containsKey(swf) && invalidBreakPointMap.get(swf).containsKey(scriptName)) {
-            lines.addAll(invalidBreakPointMap.get(swf).get(scriptName));
-        }
-        return lines;
-    }
-
-    public synchronized void clearBreakPoints(SWF swf) {
-        Map<String, Set<Integer>> breakpoints = getAllBreakPoints(swf, false);
-        for (String scriptName : breakpoints.keySet()) {
-            for (int line : breakpoints.get(scriptName)) {
-                removeBreakPoint(swf, scriptName, line);
-            }
-        }
-    }
-
-    public synchronized void makeBreakPointsUnconfirmed(SWF swf) {
-        if (confirmedPointMap.containsKey(swf)) {
-            for (String scriptName : confirmedPointMap.get(swf).keySet()) {
-                if (!toAddBPointMap.containsKey(swf)) {
-                    toAddBPointMap.put(swf, new HashMap<>());
-                }
-                if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
-                    toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
-                }
-                toAddBPointMap.get(swf).get(scriptName).addAll(confirmedPointMap.get(swf).get(scriptName));
-            }
-            confirmedPointMap.get(swf).clear();
-        }
-        if (invalidBreakPointMap.containsKey(swf)) {
-            for (String scriptName : invalidBreakPointMap.get(swf).keySet()) {
-                if (!toAddBPointMap.containsKey(swf)) {
-                    toAddBPointMap.put(swf, new HashMap<>());
-                }
-                if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
-                    toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
-                }
-                toAddBPointMap.get(swf).get(scriptName).addAll(invalidBreakPointMap.get(swf).get(scriptName));
-            }
-
-            invalidBreakPointMap.get(swf).clear();
-        }
-
-    }
-
-    public synchronized Map<String, Set<Integer>> getAllBreakPoints(SWF swf, boolean validOnly) {
-        Map<String, Set<Integer>> ret = new HashMap<>();
-        if (confirmedPointMap.containsKey(swf)) {
-            for (String scriptName : confirmedPointMap.get(swf).keySet()) {
-                Set<Integer> lines = new TreeSet<>();
-                lines.addAll(confirmedPointMap.get(swf).get(scriptName));
-                ret.put(scriptName, lines);
-            }
-        }
-        if (toAddBPointMap.containsKey(swf)) {
-            for (String scriptName : toAddBPointMap.get(swf).keySet()) {
-                if (!ret.containsKey(scriptName)) {
-                    ret.put(scriptName, new TreeSet<>());
-                }
-                ret.get(scriptName).addAll(toAddBPointMap.get(swf).get(scriptName));
-            }
-        }
-        if (!validOnly) {
-            if (invalidBreakPointMap.containsKey(swf)) {
-                for (String scriptName : invalidBreakPointMap.get(swf).keySet()) {
-                    if (!ret.containsKey(scriptName)) {
-                        ret.put(scriptName, new TreeSet<>());
-                    }
-                    ret.get(scriptName).addAll(invalidBreakPointMap.get(swf).get(scriptName));
-                }
-            }
-        }
-        return ret;
-    }
-
-    public boolean addBreakPoint(SWF swf, String scriptName, int line) {
-        synchronized (this) {
-            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "adding bp {0}:{1}", new Object[]{scriptName, line});
-            if (isBreakpointToRemove(swf, scriptName, line)) {
-                toRemoveBPointMap.get(swf).get(scriptName).remove(line);
-                if (toRemoveBPointMap.get(swf).get(scriptName).isEmpty()) {
-                    toRemoveBPointMap.get(swf).remove(scriptName);
-                }
-            }
-
-            if (isBreakpointConfirmed(swf, scriptName, line)) {
-                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "bp {0}:{1} already confirmed", new Object[]{scriptName, line});
-                return true;
-
-            }
-            if (isBreakpointInvalid(swf, scriptName, line)) {
-                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "bp {0}:{1} already invalid", new Object[]{scriptName, line});
-                return false;
-            }
-            if (!toAddBPointMap.containsKey(swf)) {
-                toAddBPointMap.put(swf, new HashMap<>());
-            }
-            if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
-                toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
-            }
-            toAddBPointMap.get(swf).get(scriptName).add(line);
-            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "bp {0}:{1} added to todo", new Object[]{scriptName, line});
-        }
-        try {
-            sendBreakPoints();
-        } catch (IOException ex) {
-            //ignored
-        }
-
-        return true;
-    }
-
-    public synchronized boolean isBreakpointConfirmed(SWF swf, String scriptName, int line) {
-        return confirmedPointMap.containsKey(swf) && confirmedPointMap.get(swf).containsKey(scriptName) && confirmedPointMap.get(swf).get(scriptName).contains(line);
-    }
-
-    public synchronized boolean isBreakpointToAdd(SWF swf, String scriptName, int line) {
-        return toAddBPointMap.containsKey(swf) && toAddBPointMap.get(swf).containsKey(scriptName) && toAddBPointMap.get(swf).get(scriptName).contains(line);
-    }
-
-    public synchronized boolean isBreakpointToRemove(SWF swf, String scriptName, int line) {
-        return toRemoveBPointMap.containsKey(swf) && toRemoveBPointMap.get(swf).containsKey(scriptName) && toRemoveBPointMap.get(swf).get(scriptName).contains(line);
-    }
-
-    public synchronized boolean isBreakpointInvalid(SWF swf, String scriptName, int line) {
-        return invalidBreakPointMap.containsKey(swf) && invalidBreakPointMap.get(swf).containsKey(scriptName) && invalidBreakPointMap.get(swf).get(scriptName).contains(line);
-    }
-
-    private synchronized void markBreakPointInvalid(SWF swf, String scriptName, int line) {
-        if (!invalidBreakPointMap.containsKey(swf)) {
-            invalidBreakPointMap.put(swf, new HashMap<>());
-        }
-        if (!invalidBreakPointMap.get(swf).containsKey(scriptName)) {
-            invalidBreakPointMap.get(swf).put(scriptName, new TreeSet<>());
-        }
-        invalidBreakPointMap.get(swf).get(scriptName).add(line);
-    }
-
-    private synchronized void markBreakPointConfirmed(SWF swf, String scriptName, int line) {
-        if (!confirmedPointMap.containsKey(swf)) {
-            confirmedPointMap.put(swf, new HashMap<>());
-        }
-        if (!confirmedPointMap.get(swf).containsKey(scriptName)) {
-            confirmedPointMap.get(swf).put(scriptName, new TreeSet<>());
-        }
-        confirmedPointMap.get(swf).get(scriptName).add(line);
-    }
-
-    private synchronized void markBreakPointValid(SWF swf, String scriptName, int line) {
-        if (!invalidBreakPointMap.containsKey(swf)) {
-            return;
-        }
-        if (!invalidBreakPointMap.get(swf).containsKey(scriptName)) {
-            return;
-        }
-        invalidBreakPointMap.get(swf).get(scriptName).remove(line);
-        if (invalidBreakPointMap.get(swf).get(scriptName).isEmpty()) {
-            invalidBreakPointMap.get(swf).remove(scriptName);
-        }
-        if (invalidBreakPointMap.get(swf).isEmpty()) {
-            invalidBreakPointMap.remove(swf);
-        }
-    }
-
-    private InFrame frame;
-
-    private int depth;
-
-    private InConstantPool pool;
-
-    private InBreakAtExt breakInfo;
-
-    private InBreakReason breakReason;
-
-    private final List<BreakListener> breakListeners = new CopyOnWriteArrayList<>();
-
-    private final List<TraceListener> traceListeners = new ArrayList<>();
-
-    private final List<ErrorListener> errorListeners = new ArrayList<>();
-
-    private final List<FrameChangeListener> frameChangeListeners = new ArrayList<>();
-
-    private final List<ConnectionListener> clisteners = new ArrayList<>();
-
-    public void setDepth(int depth) {
-        this.depth = depth;
-        refreshFrame();
-    }
-
-    public String moduleToString(int file) {
-        if (!modulePaths.containsKey(file)) {
-            return "unknown";
-        }
-        return modulePaths.get(file);
-    }
-
-    public Integer moduleToMethodIndex(int file) {
-        return moduleToMethodIndex.get(file);
-    }
-
-    public Integer moduleToClassIndex(int file) {
-        return moduleToClassIndex.get(file);
-    }
-
-    public Integer moduleToTraitIndex(int file) {
-        return moduleToTraitIndex.get(file);
-    }
-
-    public synchronized InBreakAtExt getBreakInfo() {
-        if (!paused) {
-            return null;
-        }
-        return breakInfo;
-    }
-
-    public synchronized InBreakReason getBreakReason() {
-        if (!paused) {
-            return null;
-        }
-        return breakReason;
-    }
-
     public static interface ConnectionListener {
 
-        public void connected();
+        public void connected(DebuggerSession session);
 
-        public void disconnected();
+        public void disconnected(DebuggerSession session);
     }
 
     public static interface TraceListener {
 
-        public void trace(String... val);
+        public void trace(DebuggerSession session, String... val);
     }
 
     public static interface ErrorListener {
 
-        public void errorException(String message, Variable thrownVar);
+        public void errorException(DebuggerSession session, String message, Variable thrownVar);
     }
 
     public static interface FrameChangeListener {
 
-        public void frameChanged();
+        public void frameChanged(DebuggerSession session);
     }
 
     public static interface BreakListener {
 
-        public void breakAt(String scriptName, int line, int classIndex, int traitIndex, int methodIndex);
+        public void breakAt(DebuggerSession session, String scriptName, int line, int classIndex, int traitIndex, int methodIndex);
 
-        public void doContinue();
+        public void doContinue(DebuggerSession session);
     }
 
-    public void addBreakListener(BreakListener l) {
+    private final List<DebuggerHandler.BreakListener> breakListeners = new CopyOnWriteArrayList<>();
+
+    private final List<DebuggerHandler.TraceListener> traceListeners = new ArrayList<>();
+
+    private final List<DebuggerHandler.ErrorListener> errorListeners = new ArrayList<>();
+
+    private final List<DebuggerHandler.FrameChangeListener> frameChangeListeners = new ArrayList<>();
+
+    private final List<DebuggerHandler.ConnectionListener> connectionListeners = new ArrayList<>();
+
+    public void addBreakListener(DebuggerHandler.BreakListener l) {
         breakListeners.add(l);
     }
 
-    public void addFrameChangeListener(FrameChangeListener l) {
+    public void addFrameChangeListener(DebuggerHandler.FrameChangeListener l) {
         frameChangeListeners.add(l);
     }
 
-    public void removeFrameChangeListener(FrameChangeListener l) {
+    public void removeFrameChangeListener(DebuggerHandler.FrameChangeListener l) {
         frameChangeListeners.remove(l);
     }
 
-    public void addTraceListener(TraceListener l) {
+    public void addTraceListener(DebuggerHandler.TraceListener l) {
         traceListeners.add(l);
     }
 
-    public void removeTraceListener(TraceListener l) {
+    public void removeTraceListener(DebuggerHandler.TraceListener l) {
         traceListeners.remove(l);
     }
 
-    public void addErrorListener(ErrorListener l) {
+    public void addErrorListener(DebuggerHandler.ErrorListener l) {
         errorListeners.add(l);
     }
 
-    public void removeErrorListener(ErrorListener l) {
+    public void removeErrorListener(DebuggerHandler.ErrorListener l) {
         errorListeners.remove(l);
     }
 
-    public void removeBreakListener(BreakListener l) {
+    public void removeBreakListener(DebuggerHandler.BreakListener l) {
         breakListeners.remove(l);
     }
 
-    public void addConnectionListener(ConnectionListener l) {
-        clisteners.add(l);
+    public void addConnectionListener(DebuggerHandler.ConnectionListener l) {
+        connectionListeners.add(l);
     }
 
-    public void removeConnectionListener(ConnectionListener l) {
-        clisteners.remove(l);
+    public void removeConnectionListener(DebuggerHandler.ConnectionListener l) {
+        connectionListeners.remove(l);
     }
 
-    public synchronized void refreshFrame() {
-        if (!paused) {
-            return;
-        }
-        try {
-            frame = commands.getFrame(depth);
-            pool = commands.getConstantPool(0);
-        } catch (IOException ex) {
-            //ignore
-        }
-        for (FrameChangeListener l : frameChangeListeners) {
-            l.frameChanged();
-        }
+    public List<BreakListener> getBreakListeners() {
+        return Collections.unmodifiableList(breakListeners);
     }
 
-    public synchronized InFrame getFrame() {
-        if (!paused) {
-            return null;
-        }
-        return frame;
+    public List<ErrorListener> getErrorListeners() {
+        return Collections.unmodifiableList(errorListeners);
     }
 
-    public synchronized int moduleIdOf(String packWithHash) {
-        if (!scriptToModule.containsKey(packWithHash)) {
-            return -1;
-        }
-        return scriptToModule.get(packWithHash);
+    public List<ConnectionListener> getConnectionListeners() {
+        return Collections.unmodifiableList(connectionListeners);
     }
 
-    public boolean isPaused() {
-        if (!isConnected()) {
-            return false;
-        }
-        synchronized (this) {
-            return paused;
-        }
+    public List<FrameChangeListener> getFrameChangeListeners() {
+        return Collections.unmodifiableList(frameChangeListeners);
     }
 
-    
-    private void disconnected() {
-        frame = null;
-        pool = null;
-        breakInfo = null;
-        breakReason = null;
-        connected = false;
-        commands = null;
-        synchronized (this) {
-            for (SWF debuggedSwf : debuggedSwfs) {
-                if (confirmedPointMap.containsKey(debuggedSwf)) {
-                    for (String scriptName : confirmedPointMap.get(debuggedSwf).keySet()) {
-                        if (!toAddBPointMap.containsKey(debuggedSwf)) {
-                            toAddBPointMap.put(debuggedSwf, new HashMap<>());
-                        }
-                        if (!toAddBPointMap.get(debuggedSwf).containsKey(scriptName)) {
-                            toAddBPointMap.get(debuggedSwf).put(scriptName, new TreeSet<>());
-                        }
-                        toAddBPointMap.get(debuggedSwf).get(scriptName).addAll(confirmedPointMap.get(debuggedSwf).get(scriptName));
-                    }
-                    confirmedPointMap.get(debuggedSwf).clear();
-                }
-
-                if (invalidBreakPointMap.containsKey(debuggedSwf)) {
-                    for (String scriptName : invalidBreakPointMap.get(debuggedSwf).keySet()) {
-                        if (!toAddBPointMap.containsKey(debuggedSwf)) {
-                            toAddBPointMap.put(debuggedSwf, new HashMap<>());
-                        }
-                        if (!toAddBPointMap.get(debuggedSwf).containsKey(scriptName)) {
-                            toAddBPointMap.get(debuggedSwf).put(scriptName, new TreeSet<>());
-                        }
-                        toAddBPointMap.get(debuggedSwf).get(scriptName).addAll(invalidBreakPointMap.get(debuggedSwf).get(scriptName));
-                    }
-                    invalidBreakPointMap.get(debuggedSwf).clear();
-                }
-            }
-        }
-        for (ConnectionListener l : clisteners) {
-            l.disconnected();
-        }
-        debuggedSwfs.clear();
-    }
-    
-    public void disconnect() {
-        frame = null;
-        pool = null;
-        breakInfo = null;
-        breakReason = null;
-        connected = false;
-        if (commands != null) {
-            commands.disconnect();
-        }
-        disconnected();        
-    }
-
-    public synchronized boolean isConnected() {
-        return connected;
-    }
-
-    public DebuggerCommands getCommands() throws IOException {
-        if (!isConnected() || commands == null) {
-            throw new IOException("Not connected");
-        }
-        return commands;
+    public List<TraceListener> getTraceListeners() {
+        return Collections.unmodifiableList(traceListeners);
     }
 
     @Override
@@ -664,588 +166,137 @@ public class DebuggerHandler implements DebugConnectionListener {
         View.execInEventDispatch(new Runnable() {
             @Override
             public void run() {
-                disconnect();
+                //disconnect();
                 Main.stopRun();
                 Main.stopWork();
                 ViewMessages.showMessageDialog(Main.getMainFrame().getPanel(), AppStrings.translate("error.debug.listen").replace("%port%", "" + Debugger.DEBUG_PORT));
                 Main.getMainFrame().getPanel().updateMenu();
             }
         });
-
     }
 
     @Override
-    public void connected(DebuggerConnection con) {
-        Main.startWork(AppStrings.translate("work.debugging"), null);
-
-        synchronized (this) {
-            paused = false;
-        }
-
-        Main.getMainFrame().getPanel().updateMenu();
-
-        //enlog(DebuggerConnection.class);
-        //enlog(DebuggerCommands.class);
-        //enlog(DebuggerHandler.class);
-        try {
-            con.getMessage(InVersion.class);
-        } catch (IOException ex) {
-            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.SEVERE, null, ex);
-        }
-
-        //Respond to InProcessTag with OutProcessedTag
-        con.addMessageListener(new DebugMessageListener<InProcessTag>() {
-            @Override
-            public void message(InProcessTag message) {
-                try {
-                    con.writeMessage(new OutProcessedTag(con));
-                } catch (IOException ex) {
-                    //disconnect();
-                    //ignore
-                }
-            }
-        });
-
-        swfIndicesCommitted.clear();
-        swfIndicesNewToSwfHash.clear();
-
-        Map<Integer, String> moduleNames = new HashMap<>();
-
-        final Pattern patAS3 = Pattern.compile("^(.*);(.*);(.*)\\.as$");
-        final Pattern patAS3PCode = Pattern.compile("^(?<hash>[0-9a-z_]+):#PCODE abc:(?<abc>[0-9]+),script:(?<script>[0-9]+),class:(?<class>-?[0-9]+),trait:(?<trait>-?[0-9]+),method:(?<method>[0-9]+),body:(?<body>[0-9]+);(.*)$");
-
-        //boolean isAS3 = Main.getRunningSWF().isAS3();
-        try {
-
-            con.addMessageListener(new DebugMessageListener<InErrorException>() {
-                @Override
-                public void message(InErrorException t) {
-                    for (ErrorListener l : errorListeners) {
-                        l.errorException(t.exceptionMessage, t.thrownVar);
-                    }
-                    con.dropMessage(t);
-                }
-            });
-
-            con.addMessageListener(new DebugMessageListener<InNumScript>() {
-                @Override
-                public void message(InNumScript t) {
-                    con.dropMessage(t);
-                }
-            });
-
-            modulePaths.clear();
-            scriptToModule.clear();
-            moduleNames.clear();
-            moduleToClassIndex.clear();
-            moduleToTraitIndex.clear();
-            moduleToMethodIndex.clear();
-            moduleToSwfIndex.clear();
-            
-            placedObjects.clear();
-
-            con.addMessageListener(new DebugMessageListener<InScript>() {
-                @Override
-                public void message(InScript sc) {
-                    synchronized (DebuggerHandler.this) {
-                        moduleNames.put(sc.module, sc.name);
-                        int file = sc.module;
-                        String name = sc.name;
-                        int swfIndex = sc.swfIndex;
-
-                        name = name.replaceAll("\\[(invalid_utf8=[0-9]+)\\]", "{$1}");
-
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "Received script added - index {0} name: {1}", new Object[]{file, name});
-
-                        String swfHash = "main";
-                        Matcher m;
-                        if ((m = patAS3.matcher(name)).matches()) {
-                            String clsNameWithSuffix = m.group(3).replace("{{semicolon}}", ";");
-                            String pkg = m.group(2).replace("{{semicolon}}", ";").replace("\\", ".");
-                            m = patAS3PCode.matcher(name);
-                            if (m.matches()) {
-                                moduleToClassIndex.put(file, Integer.parseInt(m.group("class")));
-                                moduleToTraitIndex.put(file, Integer.parseInt(m.group("trait")));
-                                moduleToMethodIndex.put(file, Integer.parseInt(m.group("method")));
-                                name = DottedChain.parseWithSuffix(pkg).addWithSuffix(clsNameWithSuffix).toString();
-                                swfHash = m.group("hash");
-                                name = swfHash + ":" + "#PCODE abc:" + m.group("abc") + ",body:" + m.group("body") + ";" + name;
-                            } else {
-                                if (pkg.contains(":")) {
-                                    swfHash = pkg.substring(0, pkg.indexOf(":"));
-                                    pkg = pkg.substring(pkg.indexOf(":") + 1);
-                                }
-
-                                name = swfHash + ":" + DottedChain.parseWithSuffix(pkg).addWithSuffix(clsNameWithSuffix).toPrintableString(new LinkedHashSet<>(), Main.getRunningSWF()/*???*/, con.isAS3);
-                            }
-                        } else {
-                            if (name.contains(":")) {
-                                swfHash = name.substring(0, name.indexOf(":"));
-                            }
-                        }
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "Script added - index {0} name: {1}", new Object[]{file, name});
-                        modulePaths.put(file, name);
-                        scriptToModule.put(name, file);
-                        moduleToSwfIndex.put(file, swfIndex);
-                        if (swfIndex > debuggedSwfs.size() - 1) {
-                            SWF swf = Main.getSwfByHash(swfHash);
-                            if (swf == null) {
-                                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.WARNING, "SWF with hash {0} not found", swfHash);
-                            } else {
-                                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "adding {0} to debugSwfs", swfIndex);
-                                swfIndicesCommitted.add(swfIndex);
-                                debuggedSwfs.add(swf);
-                            }
-                        } else {
-                            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "Swf index already committed");
-                        }
-                    }
-                    con.dropMessage(sc);
-                }
-            });
-
-            /*int numScript = con.getMessage(InNumScript.class).num;
-             for (int i = 0; i < numScript; i++) {
-             InScript sc = con.getMessage(InScript.class);
-             moduleNames.put(sc.module, sc.name);
-             }*/
-            //Pattern patMainFrame = Pattern.compile("^Actions for Scene ([0-9]+): Frame ([0-9]+) of Layer Name .*$");
-            //Pattern patSymbol = Pattern.compile("^Actions for Symbol ([0-9]+): Frame ([0-9]+) of Layer Name .*$");
-            //Pattern patAS2 = Pattern.compile("^([^:]+): .*\\.as$");
-            //con.getMessage(InSetBreakpoint.class);
-            commands = new DebuggerCommands(con);
-
-            commands.stopWarning();
-            commands.setStopOnFault();
-            commands.setEnumerateOverride();
-            commands.setNotifyFailure();
-            commands.setInvokeSetters();
-            commands.setSwfLoadNotify();
-            commands.setGetterTimeout(1500);
-            commands.setSetterTimeout(5000);
-
-            //Widelines - only AS3, it hangs in AS1/2 and SWD does not support UI32 lines
-            /*if (isAS3) {
-                
-            }*/
-            commands.squelch(true);
-            
-            con.addMessageListener(new DebugMessageListener<InExit>() {
-                @Override
-                public void message(InExit t) {   
-                    Logger.getLogger(DebuggerHandler.class.getName()).fine("Handling inExit");
-                    //con.dropMessage(t);
-                    synchronized (DebuggerHandler.this) {
-                        paused = false;
-                        connected = false;
-                    }
-                    Logger.getLogger(DebuggerHandler.class.getName()).fine("Calling disconnected");
-                    disconnected();
-                    Logger.getLogger(DebuggerHandler.class.getName()).fine("Disconnected called");                    
-                }                
-            });
-
-            con.writeMessage(new OutSwfInfo(con, 0));
-            con.addMessageListener(new DebugMessageListener<InSwfInfo>() {
-                @Override
-                public void message(InSwfInfo t) {
-                    /*for (InSwfInfo.SwfInfo s : t.swfInfos) {
-                        View.execInEventDispatch(new Runnable() {
-                            @Override
-                            public void run() {
-                                try {
-                                    con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
-                                    con.sendMessageWithTimeout(new OutGetSwd(con, (int) s.index), InGetSwd.class);
-                                } catch (IOException ex) {
-                                    //ignore
-                                }
-                            }
-                        });
-                    }*/
-                    con.dropMessage(t);
-                    View.execInEventDispatch(new Runnable() {
-                        @Override
-                        public void run() {
-                            for (InSwfInfo.SwfInfo s : t.swfInfos) {
-                                try {
-                                    /*try {
-                                    con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
-                                    con.sendMessageWithTimeout(new OutGetSwd(con, (int) s.index), InGetSwd.class);
-                                    } catch (IOException ex) {
-                                    //ignore
-                                    }*/
-                                    InGetSwf inGetSwf = con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
-                                    System.err.println("Received SWF");
-                                    String sha256 = Helper.byteArrayToHex(MessageDigest.getInstance("SHA-256").digest(inGetSwf.swfData));
-                                    Main.findDebuggedSwf(sha256);
-                                    
-                                    SWF debuggedSwf = Main.getDebuggedSWF();
-                                    if (debuggedSwf == null) {
-                                        con.disconnect();
-                                        synchronized (DebuggerHandler.this) {
-                                            paused = false;
-                                            connected = false;
-                                        }
-                                        disconnected();
-                                    } else {
-                                        con.isAS3 = debuggedSwf.isAS3();
-                                        if (debuggedSwf.isAS3()) {
-                                            con.wideLines = commands.getOption("wide_line_player", "false").equals("true");
-                                            if (con.wideLines) {
-                                                commands.setOption("wide_line_debugger", "on");
-                                            }
-                                        } else {
-                                            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINER, "End of connect - sending continue");
-                                            con.writeMessage(new OutRewind(con));
-                                            con.writeMessage(new OutPlay(con));
-                                            commands.sendContinue();
-                                        }
-                                    }                                            
-                                } catch (IOException | NoSuchAlgorithmException ex) {
-                                    //ignore
-                                    
-                                    con.disconnect();
-                                    synchronized (DebuggerHandler.this) {
-                                        paused = false;
-                                        connected = false;
-                                    }
-                                    disconnected();
-                                }     
-                            }
-                        }
-                    });
-                }
-            });
-            
-            con.addMessageListener(new DebugMessageListener<InPlaceObject>() {
-                @Override
-                public void message(InPlaceObject t) {
-                    placedObjects.put(t.path, t.objId);
-                    con.dropMessage(t);
-                }                
-            });
-
-            InSetBreakpoint isb = con.getMessage(InSetBreakpoint.class);
-            synchronized (this) {
-                for (int i = 0; i < isb.files.size(); i++) {
-                    String sname = moduleNames.get(isb.files.get(i));
-                    SWF debuggedSwf = debuggedSwfs.get(moduleToSwfIndex.get(isb.files.get(i)));
-                    if (!confirmedPointMap.containsKey(debuggedSwf)) {
-                        confirmedPointMap.put(debuggedSwf, new HashMap<>());
-                    }
-                    if (!confirmedPointMap.get(debuggedSwf).containsKey(sname)) {
-                        confirmedPointMap.get(debuggedSwf).put(sname, new TreeSet<>());
-                    }
-                    if (toAddBPointMap.containsKey(debuggedSwf)) {
-                        if (toAddBPointMap.get(debuggedSwf).containsKey(sname)) {
-                            toAddBPointMap.get(debuggedSwf).get(sname).remove(isb.lines.get(i));
-                            if (toAddBPointMap.get(debuggedSwf).get(sname).isEmpty()) {
-                                toAddBPointMap.get(debuggedSwf).remove(sname);
-                            }
-                        }
-                    }
-                    confirmedPointMap.get(debuggedSwf).get(sname).add(isb.lines.get(i));
-                    Logger.getLogger(DebuggerHandler.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} submitted successfully", new Object[]{sname, isb.lines.get(i)});
-                }
-            }
-
-            con.addMessageListener(new DebugMessageListener<InContinue>() {
-                @Override
-                public void message(InContinue msg) {
-                    synchronized (DebuggerHandler.this) {
-                        paused = false;
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "continued");
-                    }
-                    for (BreakListener bl : breakListeners) {
-                        bl.doContinue();
-                    }
-                }
-            });
-
-            con.addMessageListener(new DebugMessageListener<InBreakAt>() {
-                @Override
-                public void message(InBreakAt message) {
-                    synchronized (DebuggerHandler.this) {
-                        paused = true;
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "paused");
-
-                    }
-
-                    try {
-                        //ignore single InSetBreakpoint, otherwise setting breakpoints later won't work
-                        con.getMessage(InSetBreakpoint.class, DebuggerConnection.PREF_RESPONSE_TIMEOUT);
-
-                        breakInfo = con.getMessage(InBreakAtExt.class, DebuggerConnection.PREF_RESPONSE_TIMEOUT);
-                        breakReason = con.sendMessageWithTimeout(new OutGetBreakReason(con), InBreakReason.class);
-
-                        int reasonInt = breakReason == null ? 0 : breakReason.reason;
-
-                        String newBreakScriptName = "unknown";
-                        String userBreakScriptName = "unknown";
-                        if (modulePaths.containsKey(message.file)) {
-                            newBreakScriptName = modulePaths.get(message.file);
-                            userBreakScriptName = newBreakScriptName;
-                            if (newBreakScriptName.contains(":")) {
-                                String swfHash = newBreakScriptName.substring(0, newBreakScriptName.indexOf(":"));
-                                SWF swf = Main.getSwfByHash(swfHash);
-                                userBreakScriptName = swf.toString() + ": " + newBreakScriptName.substring(newBreakScriptName.indexOf(":") + 1);
-                            }
-                        } else if (reasonInt != InBreakReason.REASON_SCRIPT_LOADED) {
-                            Logger.getLogger(DebuggerCommands.class.getName()).log(Level.SEVERE, "Invalid file: {0}", message.file);
-                            //return;
-                        }
-
-                        final String[] reasonNames = new String[]{"unknown", "breakpoint", "watch", "fault", "stopRequest", "step", "halt", "scriptLoaded"};
-                        String reason = reasonInt < reasonNames.length ? reasonNames[reasonInt] : reasonNames[0];
-
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "break at {0}:{1}, reason: {2}", new Object[]{newBreakScriptName, message.line, reason});
-
-                        try {
-                            sendBreakPoints();
-                        } catch (IOException ex) {
-                            //ignore
-                            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINE, "send breakpoints exception: " + ex.getMessage());
-                        }
-
-                        synchronized (DebuggerHandler.this) {
-                            breakScriptName = newBreakScriptName;
-                            breakIp = message.line;
-
-                            if (breakInfo != null) {
-                                List<String> files = new ArrayList<>();
-                                for (int i = 0; i < breakInfo.files.size(); i++) {
-                                    files.add(Main.getDebugHandler().moduleToString(breakInfo.files.get(i)));
-                                }
-                                stackScriptNames = files;
-                                List<Integer> lines = new ArrayList<>(breakInfo.lines);
-                                stackLines = lines;
-                            }
-                        }
-
-                        if (reasonInt == InBreakReason.REASON_SCRIPT_LOADED) {
-                            if (!Configuration.debugHalt.get()) {
-                                commands.sendContinue();
-                                return;
-                            }
-                            Main.startWork(AppStrings.translate("work.halted"), null);
-                        } else {
-                            Main.startWork(AppStrings.translate("work.breakat") + userBreakScriptName + ":" + message.line + " " + AppStrings.translate("debug.break.reason." + reason), null);
-                        }
-                        depth = 0;
-                        refreshFrame();
-                        for (BreakListener l : breakListeners) {
-                            l.breakAt(newBreakScriptName, message.line,
-                                    moduleToClassIndex.containsKey(message.file) ? moduleToClassIndex.get(message.file) : -1,
-                                    moduleToTraitIndex.containsKey(message.file) ? moduleToTraitIndex.get(message.file) : -1,
-                                    moduleToMethodIndex.containsKey(message.file) ? moduleToMethodIndex.get(message.file) : -1
-                            );
-                        }
-
-                    } catch (IOException ex) {
-                        //ignore
-                    }
-
-                }
-            });
-
-            synchronized (this) {
-                connected = true;
-            }
-            /*if (!isAS3) {
-                try {
-                    commands.getConnection().writeMessage(new OutRewind(commands.getConnection()));
-                } catch (IOException ex) {
-                    Logger.getLogger(DebuggerHandler.class.getName()).log(Level.SEVERE, null, ex);
-                }
-            }*/
-
-            for (ConnectionListener l : clisteners) {
-                l.connected();
-            }
-
-            con.addMessageListener(new DebugMessageListener<InTrace>() {
-                @Override
-                public synchronized void message(InTrace tr) {
-                    for (TraceListener l : traceListeners) {
-                        l.trace(tr.text);
-                    }
-                }
-            });
-
-/*            if (!isAS3) {
-                
-            }*/
-
-        } catch (IOException ex) {
-            synchronized (this) {
-                paused = false;
-                connected = false;
-            }
-            disconnected();
-        }
-    }
-
-    private void sendBreakPoints() throws IOException {
-        if (!isConnected()) {
-            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "not sending bps, not connected");
+    public synchronized void connected(DebuggerConnection con) {
+        if (terminating) {
             return;
         }
-        synchronized (this) {
-            Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "sending breakpoints of {0} swfs", debuggedSwfs.size());
-            for (int swfIndex = 0; swfIndex < debuggedSwfs.size(); swfIndex++) {
-                if (!swfIndicesCommitted.contains(swfIndex)) {
-                    continue;
-                }
-                SWF debuggedSwf = debuggedSwfs.get(swfIndex);
-                String hash = Main.getSwfHash(debuggedSwf);
-
-                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "sending breakpoints of {0}", hash);
-
-                if (toRemoveBPointMap.containsKey(debuggedSwf)) {
-                    for (String scriptName : toRemoveBPointMap.get(debuggedSwf).keySet()) {
-                        if (scriptName.startsWith("#PCODE") != Main.isDebugPCode()) {
-                            continue;
-                        }
-                        int file = moduleIdOf(hash + ":" + scriptName);
-                        if (file > -1) {
-                            for (int line : toRemoveBPointMap.get(debuggedSwf).get(scriptName)) {
-                                if (isBreakpointConfirmed(debuggedSwf, scriptName, line)) {
-                                    commands.removeBreakPoint(file, line);
-                                    confirmedPointMap.get(debuggedSwf).get(scriptName).remove(line);
-                                    if (confirmedPointMap.get(debuggedSwf).get(scriptName).isEmpty()) {
-                                        confirmedPointMap.get(debuggedSwf).remove(scriptName);
-                                    }
-                                }
-                                Logger.getLogger(DebuggerHandler.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} removed", new Object[]{scriptName, line});
-                            }
-                        }
-                    }
-                    toRemoveBPointMap.get(debuggedSwf).clear();
-                    if (toRemoveBPointMap.get(debuggedSwf).isEmpty()) {
-                        toRemoveBPointMap.remove(debuggedSwf);
-                    }
-                }
-
-                if (toAddBPointMap.containsKey(debuggedSwf)) {
-                    Set<String> toAddScripts = new HashSet<>(toAddBPointMap.get(debuggedSwf).keySet());
-                    for (String scriptName : toAddScripts) {
-                        if (scriptName.startsWith("#PCODE") != Main.isDebugPCode()) {
-                            continue;
-                        }
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "searching for module of {0}:{1}", new Object[]{hash, scriptName});
-                        int file = moduleIdOf(hash + ":" + scriptName);
-                        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "module = {0}", file);
-                        if (file > -1) {
-                            Set<Integer> lines = new HashSet<>(toAddBPointMap.get(debuggedSwf).get(scriptName));
-                            for (int line : lines) {
-                                if (commands.addBreakPoint(file, line)) {
-                                    Logger.getLogger(DebuggerHandler.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} submitted successfully", new Object[]{scriptName, line});
-                                    markBreakPointConfirmed(debuggedSwf, scriptName, line);
-                                    markBreakPointValid(debuggedSwf, scriptName, line);
-                                    toAddBPointMap.get(debuggedSwf).get(scriptName).remove(line);
-                                    if (toAddBPointMap.get(debuggedSwf).get(scriptName).isEmpty()) {
-                                        toAddBPointMap.get(debuggedSwf).remove(scriptName);
-                                    }
-                                    if (toAddBPointMap.get(debuggedSwf).isEmpty()) {
-                                        toAddBPointMap.remove(debuggedSwf);
-                                    }
-                                } else {
-                                    Logger.getLogger(DebuggerHandler.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} unable to submit", new Object[]{scriptName, line});
-                                    markBreakPointInvalid(debuggedSwf, scriptName, line);
-                                }
-                            }
-                        } else {
-                            for (int line : toAddBPointMap.get(debuggedSwf).get(scriptName)) {
-                                markBreakPointInvalid(debuggedSwf, scriptName, line);
-                            }
-                        }
-                    }
+        Map<SWF, Map<String, Set<Integer>>> breakpoints = new LinkedHashMap<>();
+        Set<SWF> swfs = new LinkedHashSet<>(allBreakPoints.keySet());
+        for (SWF swf : swfs) {
+            breakpoints.put(swf, new LinkedHashMap<>());
+            Set<String> scriptNames = new LinkedHashSet<>(allBreakPoints.get(swf).keySet());
+            for (String scriptName : scriptNames) {
+                breakpoints.get(swf).put(scriptName, new TreeSet<>());
+                for (int line : allBreakPoints.get(swf).get(scriptName)) {
+                    breakpoints.get(swf).get(scriptName).add(line);
                 }
             }
         }
-        Logger.getLogger(DebuggerHandler.class.getName()).log(Level.FINEST, "sending bps finished");
+        
+        DebuggerSession session = new DebuggerSession(this, con, breakpoints);
+        sessions.add(session);
+    }
+
+    public void sessionInited(DebuggerSession session) {       
 
     }
 
-    public synchronized InConstantPool getConstantPool() {
-        if (!paused) {
-            return null;
-        }
-        return pool;
-    }
-
-    public synchronized InCallFunction callMethod(Variable object, String methodName, List<Object> args) throws ActionScriptException {
-        return callFunction(false, methodName, object, args);
-    }
-
-    public synchronized InCallFunction callMethod(String object, String methodName, List<Object> args) throws ActionScriptException {
-        InGetVariable igv = getVariable(0, object, false, false);
-        return callMethod(igv.parent, methodName, args);
-    }
-
-    private static String typeAsStr(Object value) {
-        if (value == null) {
-            return "null";
-        }
-        if ((value instanceof Long) || (value instanceof Integer)) {
-            return "int";
-        }
-        if (value instanceof Number) {
-            return "Number";
-        }
-        if (value instanceof String) {
-            return "String";
-        }
-        if (value instanceof Variable) {
-            Variable v = (Variable) value;
-            return v.getTypeAsStr();
-        }
-        return "String";
-    }
-
-    private static String valueAsStr(Object value) {
-        if (value == null) {
-            return "null";
-        }
-        if (value instanceof Double) {
-            double doubleValue = ((Double) value).doubleValue();
-            long longValue = (long) doubleValue;
-            if (doubleValue == longValue) {
-                return Long.toString(longValue);
+    public boolean isAnySessionConnected() {
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            if (session.isConnected()) {
+                return true;
             }
         }
-
-        if (value instanceof Variable) {
-            Variable v = (Variable) value;
-            return valueAsStr(v.value);
-        }
-        return "" + value;
+        return false;
     }
 
-    public synchronized InCallFunction callFunction(boolean isConstructor, String funcName, Variable thisValue, List<Object> args) throws ActionScriptException {
-        List<String> argTypes = new ArrayList<>();
-        List<String> argValues = new ArrayList<>();
-        for (Object value : args) {
-            argTypes.add(typeAsStr(value));
-            argValues.add(valueAsStr(value));
-        }
-        String thisType = typeAsStr(thisValue);
-        String thisValueStr = valueAsStr(thisValue);
-        try {
-            InCallFunction icf = commands.callFunction(isConstructor, funcName, thisType, thisValueStr, argTypes, argValues);
-            if (!icf.variables.isEmpty()) {
-                if ((icf.variables.get(0).flags & VariableFlags.IS_EXCEPTION) > 0) {
-                    throw new ActionScriptException("" + icf.variables.get(0).value);
-                }
+    public int getNumberOfPausedSessions() {
+        int count = 0;
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            if (session.isConnected() && session.isPaused()) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public synchronized void terminateAllSessions() {
+        terminating = true;
+        for (DebuggerSession session : sessions) {
+            if (session.isConnected()) {
+                session.disconnect();
+            }
+        }
+        terminating = false;
+    }
+
+    public synchronized Map<String, Set<Integer>> getAllSessionsBreakPoints(SWF swf) {
+        if (!allBreakPoints.containsKey(swf)) {
+            return new LinkedHashMap<>();
+        }
+
+        return Collections.unmodifiableMap(allBreakPoints.get(swf));
+    }
+
+    public synchronized Set<Integer> getAllSessionsScriptBreakPoints(SWF swf, String scriptName) {
+        if (!allBreakPoints.containsKey(swf)) {
+            return new TreeSet<>();
+        }
+        if (!allBreakPoints.get(swf).containsKey(scriptName)) {
+            return new TreeSet<>();
+        }
+
+        return Collections.unmodifiableSet(allBreakPoints.get(swf).get(scriptName));
+    }
+
+    public boolean addBreakPoint(SWF swf, String scriptName, int line) {
+        if (!allBreakPoints.containsKey(swf)) {
+            allBreakPoints.put(swf, new LinkedHashMap<>());
+        }
+        if (!allBreakPoints.get(swf).containsKey(scriptName)) {
+            allBreakPoints.get(swf).put(scriptName, new TreeSet<>());
+        }
+        allBreakPoints.get(swf).get(scriptName).add(line);
+
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            session.addBreakPoint(swf, scriptName, line);
+        }
+        return true;
+    }
+
+    public synchronized void removeBreakPoint(SWF swf, String scriptName, int line) {
+        if (!allBreakPoints.containsKey(swf)) {
+            return;
+        }
+        if (!allBreakPoints.get(swf).containsKey(scriptName)) {
+            return;
+        }
+        allBreakPoints.get(swf).get(scriptName).remove(line);
+
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            session.removeBreakPoint(swf, scriptName, line);
+        }
+    }
+
+    public void clearBreakPoints(SWF swf) {
+        allBreakPoints.remove(swf);
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            session.clearBreakPoints(swf);
+        }
+    }
+
+    public DebuggerSession getSessionContainingSwf(SWF swf) {
+        List<DebuggerSession> currentSessions = new ArrayList<>(sessions);
+        for (DebuggerSession session : currentSessions) {
+            if (session.containsSwf(swf)) {
+                return session;
             }
-            return icf;
-        } catch (IOException e) {
-            //ignored
         }
         return null;
     }
-    
-    public Map<String, Long> getPlacedObjects() {
-        return new LinkedHashMap<>(placedObjects);
-    }
 }
diff --git a/src/com/jpexs/decompiler/flash/gui/DebuggerSession.java b/src/com/jpexs/decompiler/flash/gui/DebuggerSession.java
new file mode 100644
index 000000000..58c58d460
--- /dev/null
+++ b/src/com/jpexs/decompiler/flash/gui/DebuggerSession.java
@@ -0,0 +1,1176 @@
+/*
+ * Copyright (C) 2026 JPEXS
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.jpexs.decompiler.flash.gui;
+
+import com.jpexs.debugger.flash.DebugMessageListener;
+import com.jpexs.debugger.flash.DebuggerCommands;
+import com.jpexs.debugger.flash.DebuggerConnection;
+import com.jpexs.debugger.flash.Variable;
+import com.jpexs.debugger.flash.VariableFlags;
+import com.jpexs.debugger.flash.VariableType;
+import com.jpexs.debugger.flash.messages.in.InBreakAt;
+import com.jpexs.debugger.flash.messages.in.InBreakAtExt;
+import com.jpexs.debugger.flash.messages.in.InBreakReason;
+import com.jpexs.debugger.flash.messages.in.InCallFunction;
+import com.jpexs.debugger.flash.messages.in.InConstantPool;
+import com.jpexs.debugger.flash.messages.in.InContinue;
+import com.jpexs.debugger.flash.messages.in.InErrorException;
+import com.jpexs.debugger.flash.messages.in.InExit;
+import com.jpexs.debugger.flash.messages.in.InFrame;
+import com.jpexs.debugger.flash.messages.in.InGetSwf;
+import com.jpexs.debugger.flash.messages.in.InGetVariable;
+import com.jpexs.debugger.flash.messages.in.InNumScript;
+import com.jpexs.debugger.flash.messages.in.InPlaceObject;
+import com.jpexs.debugger.flash.messages.in.InProcessTag;
+import com.jpexs.debugger.flash.messages.in.InScript;
+import com.jpexs.debugger.flash.messages.in.InSetBreakpoint;
+import com.jpexs.debugger.flash.messages.in.InSwfInfo;
+import com.jpexs.debugger.flash.messages.in.InTrace;
+import com.jpexs.debugger.flash.messages.in.InVersion;
+import com.jpexs.debugger.flash.messages.out.OutAddWatch2;
+import com.jpexs.debugger.flash.messages.out.OutGetBreakReason;
+import com.jpexs.debugger.flash.messages.out.OutGetSwf;
+import com.jpexs.debugger.flash.messages.out.OutPlay;
+import com.jpexs.debugger.flash.messages.out.OutProcessedTag;
+import com.jpexs.debugger.flash.messages.out.OutRewind;
+import com.jpexs.debugger.flash.messages.out.OutSwfInfo;
+import com.jpexs.decompiler.flash.SWF;
+import com.jpexs.decompiler.flash.configuration.Configuration;
+import com.jpexs.decompiler.graph.DottedChain;
+import com.jpexs.helpers.Helper;
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.WeakHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ * @author JPEXS
+ */
+public class DebuggerSession {
+
+    private boolean connected = false;
+    
+    private boolean inited = false;
+
+    private DebuggerCommands commands = null;
+
+    //private List<InSwfInfo.SwfInfo> swfs = new ArrayList<>();
+    private boolean paused = true;
+
+    private Map<Integer, String> modulePaths = new HashMap<>();
+
+    private Map<Integer, Integer> moduleToSwfIndex = new HashMap<>();
+
+    //Marks swfIndices that are fully loaded - at least one break was on it (including onloaded break)
+    private Set<Integer> swfIndicesCommitted = new HashSet<>();
+
+    private Map<Integer, String> swfIndicesNewToSwfHash = new HashMap<>();
+
+    private Map<String, Integer> scriptToModule = new HashMap<>();
+
+    private Map<Integer, Integer> moduleToTraitIndex = new HashMap<>();
+
+    private Map<Integer, Integer> moduleToClassIndex = new HashMap<>();
+
+    private Map<Integer, Integer> moduleToMethodIndex = new HashMap<>();
+
+    private Map<SWF, Map<String, Set<Integer>>> toAddBPointMap = new WeakHashMap<>();
+    private Map<SWF, Map<String, Set<Integer>>> toRemoveBPointMap = new WeakHashMap<>();
+
+    private Map<SWF, Map<String, Set<Integer>>> confirmedPointMap = new WeakHashMap<>();
+
+    private Map<SWF, Map<String, Set<Integer>>> invalidBreakPointMap = new WeakHashMap<>();
+
+    private int breakIp = -1;
+
+    private String breakScriptName = null;
+
+    private List<String> stackScriptNames = new ArrayList<>();
+
+    private List<Integer> stackLines = new ArrayList<>();
+
+    private List<SWF> debuggedSwfs = new ArrayList<>();
+
+    private Map<String, Long> placedObjects = new LinkedHashMap<>();
+
+    private InFrame frame;
+
+    private int depth;
+
+    private InConstantPool pool;
+
+    private InBreakAtExt breakInfo;
+
+    private InBreakReason breakReason;
+
+    private DebuggerHandler handler;
+    
+    private InSetBreakpoint inSetBreakpoint;
+    
+    private int id;
+    
+    private static int lastId = 0;
+
+    public DebuggerSession(DebuggerHandler handler, DebuggerConnection con, Map<SWF, Map<String, Set<Integer>>> breakpoints) {
+        lastId++;
+        id = lastId;
+        
+        toAddBPointMap = breakpoints;
+        this.handler = handler;
+        Main.startWork(AppStrings.translate("work.debugging"), null);
+
+        synchronized (this) {
+            paused = false;
+        }
+
+        Main.getMainFrame().getPanel().updateMenu();
+
+        //enlog(DebuggerConnection.class);
+        //enlog(DebuggerCommands.class);
+        //enlog(DebuggerHandler.class);
+        try {
+            con.getMessage(InVersion.class);
+        } catch (IOException ex) {
+            Logger.getLogger(DebuggerSession.class.getName()).log(Level.SEVERE, null, ex);
+        }
+
+        //Respond to InProcessTag with OutProcessedTag
+        con.addMessageListener(new DebugMessageListener<InProcessTag>() {
+            @Override
+            public void message(InProcessTag message) {
+                try {
+                    con.writeMessage(new OutProcessedTag(con));
+                } catch (IOException ex) {
+                    //disconnect();
+                    //ignore
+                }
+            }
+        });
+
+        swfIndicesCommitted.clear();
+        swfIndicesNewToSwfHash.clear();
+
+        Map<Integer, String> moduleNames = new HashMap<>();
+
+        final Pattern patAS3 = Pattern.compile("^(.*);(.*);(.*)\\.as$");
+        final Pattern patAS3PCode = Pattern.compile("^(?<hash>[0-9a-z_]+):#PCODE abc:(?<abc>[0-9]+),script:(?<script>[0-9]+),class:(?<class>-?[0-9]+),trait:(?<trait>-?[0-9]+),method:(?<method>[0-9]+),body:(?<body>[0-9]+);(.*)$");
+
+        //boolean isAS3 = Main.getRunningSWF().isAS3();
+        try {
+
+            con.addMessageListener(new DebugMessageListener<InErrorException>() {
+                @Override
+                public void message(InErrorException t) {
+                    for (DebuggerHandler.ErrorListener l : handler.getErrorListeners()) {
+                        l.errorException(DebuggerSession.this, t.exceptionMessage, t.thrownVar);
+                    }
+                    con.dropMessage(t);
+                }
+            });
+
+            con.addMessageListener(new DebugMessageListener<InNumScript>() {
+                @Override
+                public void message(InNumScript t) {
+                    con.dropMessage(t);
+                }
+            });
+
+            modulePaths.clear();
+            scriptToModule.clear();
+            moduleNames.clear();
+            moduleToClassIndex.clear();
+            moduleToTraitIndex.clear();
+            moduleToMethodIndex.clear();
+            moduleToSwfIndex.clear();
+
+            placedObjects.clear();
+
+            con.addMessageListener(new DebugMessageListener<InScript>() {
+                @Override
+                public void message(InScript sc) {
+                    synchronized (DebuggerSession.this) {
+                        moduleNames.put(sc.module, sc.name);
+                        int file = sc.module;
+                        String name = sc.name;
+                        int swfIndex = sc.swfIndex;
+
+                        name = name.replaceAll("\\[(invalid_utf8=[0-9]+)\\]", "{$1}");
+
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "Received script added - index {0} name: {1}", new Object[]{file, name});
+
+                        String swfHash = "main";
+                        Matcher m;
+                        if ((m = patAS3.matcher(name)).matches()) {
+                            String clsNameWithSuffix = m.group(3).replace("{{semicolon}}", ";");
+                            String pkg = m.group(2).replace("{{semicolon}}", ";").replace("\\", ".");
+                            m = patAS3PCode.matcher(name);
+                            if (m.matches()) {
+                                moduleToClassIndex.put(file, Integer.parseInt(m.group("class")));
+                                moduleToTraitIndex.put(file, Integer.parseInt(m.group("trait")));
+                                moduleToMethodIndex.put(file, Integer.parseInt(m.group("method")));
+                                name = DottedChain.parseWithSuffix(pkg).addWithSuffix(clsNameWithSuffix).toString();
+                                swfHash = m.group("hash");
+                                name = swfHash + ":" + "#PCODE abc:" + m.group("abc") + ",body:" + m.group("body") + ";" + name;
+                            } else {
+                                if (pkg.contains(":")) {
+                                    swfHash = pkg.substring(0, pkg.indexOf(":"));
+                                    pkg = pkg.substring(pkg.indexOf(":") + 1);
+                                }
+
+                                name = swfHash + ":" + DottedChain.parseWithSuffix(pkg).addWithSuffix(clsNameWithSuffix).toPrintableString(new LinkedHashSet<>(), Main.getRunningSWF()/*???*/, con.isAS3);
+                            }
+                        } else {
+                            if (name.contains(":")) {
+                                swfHash = name.substring(0, name.indexOf(":"));
+                            }
+                        }
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "Script added - index {0} name: {1}", new Object[]{file, name});
+                        modulePaths.put(file, name);
+                        scriptToModule.put(name, file);
+                        moduleToSwfIndex.put(file, swfIndex);
+                        /*if (swfIndex > debuggedSwfs.size() - 1) {
+                            SWF swf = Main.getSwfByHash(swfHash);
+                            if (swf == null) {
+                                Logger.getLogger(DebuggerSession.class.getName()).log(Level.WARNING, "SWF with hash {0} not found", swfHash);
+                            } else {
+                                Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "adding {0} to debugSwfs", swfIndex);
+                                swfIndicesCommitted.add(swfIndex);
+                                debuggedSwfs.add(swf);
+                            }
+                        } else {
+                            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "Swf index already committed");
+                        }*/
+                        swfIndicesCommitted.add(swfIndex);
+                    }
+                    con.dropMessage(sc);
+                }
+            });
+
+            /*int numScript = con.getMessage(InNumScript.class).num;
+             for (int i = 0; i < numScript; i++) {
+             InScript sc = con.getMessage(InScript.class);
+             moduleNames.put(sc.module, sc.name);
+             }*/
+            //Pattern patMainFrame = Pattern.compile("^Actions for Scene ([0-9]+): Frame ([0-9]+) of Layer Name .*$");
+            //Pattern patSymbol = Pattern.compile("^Actions for Symbol ([0-9]+): Frame ([0-9]+) of Layer Name .*$");
+            //Pattern patAS2 = Pattern.compile("^([^:]+): .*\\.as$");
+            //con.getMessage(InSetBreakpoint.class);
+            commands = new DebuggerCommands(con);
+
+            commands.stopWarning();
+            commands.setStopOnFault();
+            commands.setEnumerateOverride();
+            commands.setNotifyFailure();
+            commands.setInvokeSetters();
+            commands.setSwfLoadNotify();
+            commands.setGetterTimeout(1500);
+            commands.setSetterTimeout(5000);
+
+            commands.squelch(true);
+
+            con.addMessageListener(new DebugMessageListener<InExit>() {
+                @Override
+                public void message(InExit t) {
+                    Logger.getLogger(DebuggerSession.class.getName()).fine("Handling inExit");
+                    //con.dropMessage(t);
+                    synchronized (DebuggerSession.this) {
+                        paused = false;
+                        connected = false;
+                    }
+                    Logger.getLogger(DebuggerSession.class.getName()).fine("Calling disconnected");
+                    disconnected();
+                    Logger.getLogger(DebuggerSession.class.getName()).fine("Disconnected called");
+                }
+            });
+
+            con.writeMessage(new OutSwfInfo(con, 0));
+            con.addMessageListener(new DebugMessageListener<InSwfInfo>() {
+                @Override
+                public void message(InSwfInfo t) {
+                    /*for (InSwfInfo.SwfInfo s : t.swfInfos) {
+                        View.execInEventDispatch(new Runnable() {
+                            @Override
+                            public void run() {
+                                try {
+                                    con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
+                                    con.sendMessageWithTimeout(new OutGetSwd(con, (int) s.index), InGetSwd.class);
+                                } catch (IOException ex) {
+                                    //ignore
+                                }
+                            }
+                        });
+                    }*/
+                    con.dropMessage(t);
+                    View.execInEventDispatch(new Runnable() {
+                        @Override
+                        public void run() {
+                            for (InSwfInfo.SwfInfo s : t.swfInfos) {
+                                try {
+                                    /*try {
+                                    con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
+                                    con.sendMessageWithTimeout(new OutGetSwd(con, (int) s.index), InGetSwd.class);
+                                    } catch (IOException ex) {
+                                    //ignore
+                                    }*/                                    
+                                    InGetSwf inGetSwf = con.sendMessageWithTimeout(new OutGetSwf(con, (int) s.index), InGetSwf.class);
+                                    Logger.getLogger(DebuggerSession.class.getName()).fine("Received SWF");
+                                    Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "Received SWF.URL = {0}", s.url);
+                                    
+                                    String sha256 = Helper.byteArrayToHex(MessageDigest.getInstance("SHA-256").digest(inGetSwf.swfData));
+
+                                    SWF debuggedSwf = Main.findOpenedSwfByHash(sha256);
+                                    if (debuggedSwf == null) {
+                                        con.disconnect();
+                                        synchronized (DebuggerSession.this) {
+                                            paused = false;
+                                            connected = false;
+                                        }
+                                        disconnected();
+                                    } else {
+                                        debuggedSwfs.add(debuggedSwf);
+                                        if (debuggedSwfs.size() == 1) { //it's the first one
+                                            con.isAS3 = debuggedSwf.isAS3();
+                                        }
+                                    }                                    
+                                } catch (IOException | NoSuchAlgorithmException ex) {
+                                    //ignore
+
+                                    con.disconnect();
+                                    synchronized (DebuggerSession.this) {
+                                        paused = false;
+                                        connected = false;
+                                    }
+                                    disconnected();
+                                    return;
+                                }
+                            }
+
+                            try {
+                                
+                                if (con.isAS3) {
+                                    //Widelines - only AS3, it hangs in AS1/2 and SWD does not support UI32 lines          
+                                    con.wideLines = commands.getOption("wide_line_player", "false").equals("true");
+                                    if (con.wideLines) {
+                                        commands.setOption("wide_line_debugger", "on");
+                                    }
+                                } else {
+                                    Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINER, "End of connect - sending continue");
+                                    con.writeMessage(new OutRewind(con));
+                                    con.writeMessage(new OutPlay(con));
+                                    commands.sendContinue();
+                                }
+                                
+                                synchronized (DebuggerSession.this) {
+                                    for (int i = 0; i < inSetBreakpoint.files.size(); i++) {
+                                        String sname = moduleNames.get(inSetBreakpoint.files.get(i));
+                                        int swfIndex = moduleToSwfIndex.get(inSetBreakpoint.files.get(i));
+                                        SWF debuggedSwf = debuggedSwfs.get(swfIndex);
+                                        if (!confirmedPointMap.containsKey(debuggedSwf)) {
+                                            confirmedPointMap.put(debuggedSwf, new HashMap<>());
+                                        }
+                                        if (!confirmedPointMap.get(debuggedSwf).containsKey(sname)) {
+                                            confirmedPointMap.get(debuggedSwf).put(sname, new TreeSet<>());
+                                        }
+                                        if (toAddBPointMap.containsKey(debuggedSwf)) {
+                                            if (toAddBPointMap.get(debuggedSwf).containsKey(sname)) {
+                                                toAddBPointMap.get(debuggedSwf).get(sname).remove(inSetBreakpoint.lines.get(i));
+                                                if (toAddBPointMap.get(debuggedSwf).get(sname).isEmpty()) {
+                                                    toAddBPointMap.get(debuggedSwf).remove(sname);
+                                                }
+                                            }
+                                        }
+                                        confirmedPointMap.get(debuggedSwf).get(sname).add(inSetBreakpoint.lines.get(i));
+                                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} submitted successfully", new Object[]{sname, inSetBreakpoint.lines.get(i)});
+                                    }
+                                }
+                                
+                                inited = true;
+                                handler.sessionInited(DebuggerSession.this);
+                            } catch (IOException ex) {
+                                con.disconnect();
+                                synchronized (DebuggerSession.this) {
+                                    paused = false;
+                                    connected = false;
+                                }
+                                disconnected();
+                            }
+                        }
+                    });
+                }
+            });
+
+            con.addMessageListener(new DebugMessageListener<InPlaceObject>() {
+                @Override
+                public void message(InPlaceObject t) {
+                    placedObjects.put(t.path, t.objId);
+                    con.dropMessage(t);
+                }
+            });
+
+            inSetBreakpoint = con.getMessage(InSetBreakpoint.class);            
+
+            con.addMessageListener(new DebugMessageListener<InContinue>() {
+                @Override
+                public void message(InContinue msg) {
+                    synchronized (DebuggerSession.this) {
+                        paused = false;
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "continued");
+                    }
+                    for (DebuggerHandler.BreakListener bl : handler.getBreakListeners()) {
+                        bl.doContinue(DebuggerSession.this);
+                    }
+                }
+            });
+
+            con.addMessageListener(new DebugMessageListener<InBreakAt>() {
+                @Override
+                public void message(InBreakAt message) {
+                    synchronized (DebuggerSession.this) {
+                        paused = true;
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "paused");
+
+                    }
+
+                    try {
+                        //ignore single InSetBreakpoint, otherwise setting breakpoints later won't work
+                        con.getMessage(InSetBreakpoint.class, DebuggerConnection.PREF_RESPONSE_TIMEOUT);
+
+                        breakInfo = con.getMessage(InBreakAtExt.class, DebuggerConnection.PREF_RESPONSE_TIMEOUT);
+                        breakReason = con.sendMessageWithTimeout(new OutGetBreakReason(con), InBreakReason.class);
+
+                        int reasonInt = breakReason == null ? 0 : breakReason.reason;
+
+                        String newBreakScriptName = "unknown";
+                        String userBreakScriptName = "unknown";
+                        if (modulePaths.containsKey(message.file)) {                                      
+                            newBreakScriptName = modulePaths.get(message.file);
+                            userBreakScriptName = newBreakScriptName;
+                            if (newBreakScriptName.contains(":")) {
+                                //String swfHash = newBreakScriptName.substring(0, newBreakScriptName.indexOf(":"));
+                                //SWF swf = Main.getSwfByHash(swfHash);
+                                SWF swf = debuggedSwfs.get(moduleToSwfIndex.get(message.file));
+                                
+                                userBreakScriptName = swf.toString() + ": " + newBreakScriptName.substring(newBreakScriptName.indexOf(":") + 1);
+                            }
+                        } else if (reasonInt != InBreakReason.REASON_SCRIPT_LOADED) {
+                            Logger.getLogger(DebuggerCommands.class.getName()).log(Level.SEVERE, "Invalid file: {0}", message.file);
+                            //return;
+                        }
+
+                        final String[] reasonNames = new String[]{"unknown", "breakpoint", "watch", "fault", "stopRequest", "step", "halt", "scriptLoaded"};
+                        String reason = reasonInt < reasonNames.length ? reasonNames[reasonInt] : reasonNames[0];
+
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "break at {0}:{1}, reason: {2}", new Object[]{newBreakScriptName, message.line, reason});
+
+                        try {
+                            sendBreakPoints();
+                        } catch (IOException ex) {
+                            //ignore
+                            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "send breakpoints exception: " + ex.getMessage());
+                        }
+
+                        synchronized (DebuggerSession.this) {
+                            breakScriptName = newBreakScriptName;
+                            breakIp = message.line;
+
+                            if (breakInfo != null) {
+                                List<String> files = new ArrayList<>();
+                                for (int i = 0; i < breakInfo.files.size(); i++) {
+                                    files.add(DebuggerSession.this.moduleToString(breakInfo.files.get(i)));
+                                }
+                                stackScriptNames = files;
+                                List<Integer> lines = new ArrayList<>(breakInfo.lines);
+                                stackLines = lines;
+                            }
+                        }
+
+                        if (reasonInt == InBreakReason.REASON_SCRIPT_LOADED) {
+                            if (!Configuration.debugHalt.get()) {
+                                commands.sendContinue();
+                                return;
+                            }
+                            Main.startWork(AppStrings.translate("work.halted"), null, true);
+                        } else {
+                            Main.startWork(AppStrings.translate("work.breakat") + userBreakScriptName + ":" + message.line + " " + AppStrings.translate("debug.break.reason." + reason), null, true);
+                        }
+                        depth = 0;
+                        refreshFrame();
+                        for (DebuggerHandler.BreakListener l : handler.getBreakListeners()) {
+                            l.breakAt(DebuggerSession.this, newBreakScriptName, message.line,
+                                    moduleToClassIndex.containsKey(message.file) ? moduleToClassIndex.get(message.file) : -1,
+                                    moduleToTraitIndex.containsKey(message.file) ? moduleToTraitIndex.get(message.file) : -1,
+                                    moduleToMethodIndex.containsKey(message.file) ? moduleToMethodIndex.get(message.file) : -1
+                            );
+                        }
+
+                    } catch (IOException ex) {
+                        //ignore
+                    }
+
+                }
+            });
+
+            synchronized (this) {
+                connected = true;
+            }
+            /*if (!isAS3) {
+                try {
+                    commands.getConnection().writeMessage(new OutRewind(commands.getConnection()));
+                } catch (IOException ex) {
+                    Logger.getLogger(DebuggerSession.class.getName()).log(Level.SEVERE, null, ex);
+                }
+            }*/
+
+            for (DebuggerHandler.ConnectionListener l : handler.getConnectionListeners()) {
+                l.connected(DebuggerSession.this);
+            }
+
+            con.addMessageListener(new DebugMessageListener<InTrace>() {
+                @Override
+                public synchronized void message(InTrace tr) {
+                    for (DebuggerHandler.TraceListener l : handler.getTraceListeners()) {
+                        l.trace(DebuggerSession.this, tr.text);
+                    }
+                }
+            });
+
+            /*            if (!isAS3) {
+                
+            }*/
+        } catch (IOException ex) {
+            synchronized (this) {
+                paused = false;
+                connected = false;
+            }
+            disconnected();
+        }
+    }
+    
+    public boolean containsSwf(SWF swf) {
+        return debuggedSwfs.contains(swf);
+    }
+
+    public void setMainDebuggedSwf(SWF debuggedSwf) {
+        debuggedSwfs.clear();
+        //debuggedSwfs.add(debuggedSwf);
+    }
+
+    public List<SWF> getDebuggedSwfs() {
+        return debuggedSwfs;
+    }
+
+    public int getBreakIp() {
+        if (!isPaused()) {
+            return -1;
+        }
+        return breakIp;
+    }
+
+    public int getDepth() {
+        return depth;
+    }
+
+    public String getBreakScriptName() {
+        if (!isPaused()) {
+            return "-";
+        }
+        return breakScriptName;
+    }
+
+    public synchronized List<String> getStackScripts() {
+        if (!isPaused()) {
+            return new ArrayList<>();
+        }
+        return stackScriptNames;
+    }
+
+    public synchronized List<Integer> getStackLines() {
+        if (!isPaused()) {
+            return new ArrayList<>();
+        }
+        return stackLines;
+    }
+
+    public InGetVariable getVariable(long parentId, String varName, boolean children, boolean useGetter) {
+        try {
+            return commands.getVariable(parentId, varName, useGetter, children);
+        } catch (IOException ex) {
+            return null;
+        }
+    }
+
+    public void setVariable(long parentId, String varName, int valueType, Object value) {
+        try {
+            String svalue = "";
+            switch (valueType) {
+                case VariableType.STRING:
+                    svalue = "" + value;
+                    break;
+                case VariableType.NUMBER:
+                    svalue = "" + value;
+                    break;
+                case VariableType.BOOLEAN:
+                    svalue = ((Boolean) value) ? "true" : "false";
+                    break;
+                case VariableType.UNDEFINED:
+                    svalue = "undefined";
+                    break;
+                case VariableType.NULL:
+                    svalue = "undefined";
+                    break;
+            }
+            commands.setVariable(parentId, varName, valueType, svalue);
+        } catch (IOException ex) {
+            //ignore
+        }
+    }
+
+    public synchronized void removeBreakPoint(SWF swf, String scriptName, int line) {
+        if (isBreakpointInvalid(swf, scriptName, line)) {
+            invalidBreakPointMap.get(swf).get(scriptName).remove(line);
+            if (invalidBreakPointMap.get(swf).get(scriptName).isEmpty()) {
+                invalidBreakPointMap.get(swf).remove(scriptName);
+            }
+            return;
+        }
+        if (isBreakpointToAdd(swf, scriptName, line)) {
+            toAddBPointMap.get(swf).get(scriptName).remove(line);
+            if (toAddBPointMap.get(swf).get(scriptName).isEmpty()) {
+                toAddBPointMap.get(swf).remove(scriptName);
+            }
+        } else if (isBreakpointConfirmed(swf, scriptName, line)) {
+            if (!toRemoveBPointMap.containsKey(swf)) {
+                toRemoveBPointMap.put(swf, new HashMap<>());
+            }
+            if (!toRemoveBPointMap.get(swf).containsKey(scriptName)) {
+                toRemoveBPointMap.get(swf).put(scriptName, new TreeSet<>());
+            }
+            toRemoveBPointMap.get(swf).get(scriptName).add(line);
+        }
+        try {
+            sendBreakPoints();
+        } catch (IOException ex) {
+            //ignore
+        }
+    }
+
+    private int watchTag = 1;
+
+    public synchronized com.jpexs.debugger.flash.DebuggerCommands.Watch addWatch(Variable v, long v_id, boolean watchRead, boolean watchWrite) {
+        int tag = watchTag++;
+        try {
+            return commands.addWatch(v_id, v.name, (watchRead ? OutAddWatch2.FLAG_READ : 0) | (watchWrite ? OutAddWatch2.FLAG_WRITE : 0), tag);
+        } catch (IOException ex) {
+            return null;
+        }
+    }
+
+    public synchronized Set<Integer> getBreakPoints(SWF swf, String scriptName, boolean onlyValid) {
+        Set<Integer> lines = new TreeSet<>();
+        if (confirmedPointMap.containsKey(swf) && confirmedPointMap.get(swf).containsKey(scriptName)) {
+            lines.addAll(confirmedPointMap.get(swf).get(scriptName));
+        }
+        if (toAddBPointMap.containsKey(swf) && toAddBPointMap.get(swf).containsKey(scriptName)) {
+            lines.addAll(toAddBPointMap.get(swf).get(scriptName));
+        }
+        if (!onlyValid && invalidBreakPointMap.containsKey(swf) && invalidBreakPointMap.get(swf).containsKey(scriptName)) {
+            lines.addAll(invalidBreakPointMap.get(swf).get(scriptName));
+        }
+        return lines;
+    }
+
+    public synchronized void clearBreakPoints(SWF swf) {
+        Map<String, Set<Integer>> breakpoints = getAllBreakPoints(swf, false);
+        for (String scriptName : breakpoints.keySet()) {
+            for (int line : breakpoints.get(scriptName)) {
+                removeBreakPoint(swf, scriptName, line);
+            }
+        }
+    }
+
+    public synchronized void makeBreakPointsUnconfirmed(SWF swf) {
+        if (confirmedPointMap.containsKey(swf)) {
+            for (String scriptName : confirmedPointMap.get(swf).keySet()) {
+                if (!toAddBPointMap.containsKey(swf)) {
+                    toAddBPointMap.put(swf, new HashMap<>());
+                }
+                if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
+                    toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
+                }
+                toAddBPointMap.get(swf).get(scriptName).addAll(confirmedPointMap.get(swf).get(scriptName));
+            }
+            confirmedPointMap.get(swf).clear();
+        }
+        if (invalidBreakPointMap.containsKey(swf)) {
+            for (String scriptName : invalidBreakPointMap.get(swf).keySet()) {
+                if (!toAddBPointMap.containsKey(swf)) {
+                    toAddBPointMap.put(swf, new HashMap<>());
+                }
+                if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
+                    toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
+                }
+                toAddBPointMap.get(swf).get(scriptName).addAll(invalidBreakPointMap.get(swf).get(scriptName));
+            }
+
+            invalidBreakPointMap.get(swf).clear();
+        }
+
+    }
+
+    public synchronized Map<String, Set<Integer>> getAllBreakPoints(SWF swf, boolean validOnly) {
+        Map<String, Set<Integer>> ret = new HashMap<>();
+        if (confirmedPointMap.containsKey(swf)) {
+            for (String scriptName : confirmedPointMap.get(swf).keySet()) {
+                Set<Integer> lines = new TreeSet<>();
+                lines.addAll(confirmedPointMap.get(swf).get(scriptName));
+                ret.put(scriptName, lines);
+            }
+        }
+        if (toAddBPointMap.containsKey(swf)) {
+            for (String scriptName : toAddBPointMap.get(swf).keySet()) {
+                if (!ret.containsKey(scriptName)) {
+                    ret.put(scriptName, new TreeSet<>());
+                }
+                ret.get(scriptName).addAll(toAddBPointMap.get(swf).get(scriptName));
+            }
+        }
+        if (!validOnly) {
+            if (invalidBreakPointMap.containsKey(swf)) {
+                for (String scriptName : invalidBreakPointMap.get(swf).keySet()) {
+                    if (!ret.containsKey(scriptName)) {
+                        ret.put(scriptName, new TreeSet<>());
+                    }
+                    ret.get(scriptName).addAll(invalidBreakPointMap.get(swf).get(scriptName));
+                }
+            }
+        }
+        return ret;
+    }
+
+    public boolean addBreakPoint(SWF swf, String scriptName, int line) {
+        synchronized (this) {
+            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "adding bp {0}:{1}", new Object[]{scriptName, line});
+            if (isBreakpointToRemove(swf, scriptName, line)) {
+                toRemoveBPointMap.get(swf).get(scriptName).remove(line);
+                if (toRemoveBPointMap.get(swf).get(scriptName).isEmpty()) {
+                    toRemoveBPointMap.get(swf).remove(scriptName);
+                }
+            }
+
+            if (isBreakpointConfirmed(swf, scriptName, line)) {
+                Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "bp {0}:{1} already confirmed", new Object[]{scriptName, line});
+                return true;
+
+            }
+            if (isBreakpointInvalid(swf, scriptName, line)) {
+                Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "bp {0}:{1} already invalid", new Object[]{scriptName, line});
+                return false;
+            }
+            if (!toAddBPointMap.containsKey(swf)) {
+                toAddBPointMap.put(swf, new HashMap<>());
+            }
+            if (!toAddBPointMap.get(swf).containsKey(scriptName)) {
+                toAddBPointMap.get(swf).put(scriptName, new TreeSet<>());
+            }
+            toAddBPointMap.get(swf).get(scriptName).add(line);
+            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINE, "bp {0}:{1} added to todo", new Object[]{scriptName, line});
+        }
+        try {
+            sendBreakPoints();
+        } catch (IOException ex) {
+            //ignored
+        }
+
+        return true;
+    }
+
+    public synchronized boolean isBreakpointConfirmed(SWF swf, String scriptName, int line) {
+        return confirmedPointMap.containsKey(swf) && confirmedPointMap.get(swf).containsKey(scriptName) && confirmedPointMap.get(swf).get(scriptName).contains(line);
+    }
+
+    public synchronized boolean isBreakpointToAdd(SWF swf, String scriptName, int line) {
+        return toAddBPointMap.containsKey(swf) && toAddBPointMap.get(swf).containsKey(scriptName) && toAddBPointMap.get(swf).get(scriptName).contains(line);
+    }
+
+    public synchronized boolean isBreakpointToRemove(SWF swf, String scriptName, int line) {
+        return toRemoveBPointMap.containsKey(swf) && toRemoveBPointMap.get(swf).containsKey(scriptName) && toRemoveBPointMap.get(swf).get(scriptName).contains(line);
+    }
+
+    public synchronized boolean isBreakpointInvalid(SWF swf, String scriptName, int line) {
+        return invalidBreakPointMap.containsKey(swf) && invalidBreakPointMap.get(swf).containsKey(scriptName) && invalidBreakPointMap.get(swf).get(scriptName).contains(line);
+    }
+
+    private synchronized void markBreakPointInvalid(SWF swf, String scriptName, int line) {
+        if (!invalidBreakPointMap.containsKey(swf)) {
+            invalidBreakPointMap.put(swf, new HashMap<>());
+        }
+        if (!invalidBreakPointMap.get(swf).containsKey(scriptName)) {
+            invalidBreakPointMap.get(swf).put(scriptName, new TreeSet<>());
+        }
+        invalidBreakPointMap.get(swf).get(scriptName).add(line);
+    }
+
+    private synchronized void markBreakPointConfirmed(SWF swf, String scriptName, int line) {
+        if (!confirmedPointMap.containsKey(swf)) {
+            confirmedPointMap.put(swf, new HashMap<>());
+        }
+        if (!confirmedPointMap.get(swf).containsKey(scriptName)) {
+            confirmedPointMap.get(swf).put(scriptName, new TreeSet<>());
+        }
+        confirmedPointMap.get(swf).get(scriptName).add(line);
+    }
+
+    private synchronized void markBreakPointValid(SWF swf, String scriptName, int line) {
+        if (!invalidBreakPointMap.containsKey(swf)) {
+            return;
+        }
+        if (!invalidBreakPointMap.get(swf).containsKey(scriptName)) {
+            return;
+        }
+        invalidBreakPointMap.get(swf).get(scriptName).remove(line);
+        if (invalidBreakPointMap.get(swf).get(scriptName).isEmpty()) {
+            invalidBreakPointMap.get(swf).remove(scriptName);
+        }
+        if (invalidBreakPointMap.get(swf).isEmpty()) {
+            invalidBreakPointMap.remove(swf);
+        }
+    }
+
+    public void setDepth(int depth) {
+        this.depth = depth;
+        refreshFrame();
+    }
+
+    public String moduleToString(int file) {
+        if (!modulePaths.containsKey(file)) {
+            return "unknown";
+        }
+        return modulePaths.get(file);
+    }
+
+    public Integer moduleToMethodIndex(int file) {
+        return moduleToMethodIndex.get(file);
+    }
+
+    public Integer moduleToClassIndex(int file) {
+        return moduleToClassIndex.get(file);
+    }
+
+    public Integer moduleToTraitIndex(int file) {
+        return moduleToTraitIndex.get(file);
+    }
+
+    public synchronized InBreakAtExt getBreakInfo() {
+        if (!paused) {
+            return null;
+        }
+        return breakInfo;
+    }
+
+    public synchronized InBreakReason getBreakReason() {
+        if (!paused) {
+            return null;
+        }
+        return breakReason;
+    }
+
+    public synchronized void refreshFrame() {
+        if (!paused) {
+            return;
+        }
+        try {
+            frame = commands.getFrame(depth);
+            pool = commands.getConstantPool(0);
+        } catch (IOException ex) {
+            //ignore
+        }
+        for (DebuggerHandler.FrameChangeListener l : handler.getFrameChangeListeners()) {
+            l.frameChanged(DebuggerSession.this);
+        }
+    }
+
+    public synchronized InFrame getFrame() {
+        if (!paused) {
+            return null;
+        }
+        return frame;
+    }
+
+    public synchronized int moduleIdOf(String packWithHash) {
+        if (!scriptToModule.containsKey(packWithHash)) {
+            return -1;
+        }
+        return scriptToModule.get(packWithHash);
+    }
+
+    public boolean isPaused() {
+        if (!isConnected()) {
+            return false;
+        }
+        synchronized (this) {
+            return paused;
+        }
+    }
+
+    private void disconnected() {
+        frame = null;
+        pool = null;
+        breakInfo = null;
+        breakReason = null;
+        connected = false;
+        commands = null;
+        synchronized (this) {
+            for (SWF debuggedSwf : debuggedSwfs) {
+                if (confirmedPointMap.containsKey(debuggedSwf)) {
+                    for (String scriptName : confirmedPointMap.get(debuggedSwf).keySet()) {
+                        if (!toAddBPointMap.containsKey(debuggedSwf)) {
+                            toAddBPointMap.put(debuggedSwf, new HashMap<>());
+                        }
+                        if (!toAddBPointMap.get(debuggedSwf).containsKey(scriptName)) {
+                            toAddBPointMap.get(debuggedSwf).put(scriptName, new TreeSet<>());
+                        }
+                        toAddBPointMap.get(debuggedSwf).get(scriptName).addAll(confirmedPointMap.get(debuggedSwf).get(scriptName));
+                    }
+                    confirmedPointMap.get(debuggedSwf).clear();
+                }
+
+                if (invalidBreakPointMap.containsKey(debuggedSwf)) {
+                    for (String scriptName : invalidBreakPointMap.get(debuggedSwf).keySet()) {
+                        if (!toAddBPointMap.containsKey(debuggedSwf)) {
+                            toAddBPointMap.put(debuggedSwf, new HashMap<>());
+                        }
+                        if (!toAddBPointMap.get(debuggedSwf).containsKey(scriptName)) {
+                            toAddBPointMap.get(debuggedSwf).put(scriptName, new TreeSet<>());
+                        }
+                        toAddBPointMap.get(debuggedSwf).get(scriptName).addAll(invalidBreakPointMap.get(debuggedSwf).get(scriptName));
+                    }
+                    invalidBreakPointMap.get(debuggedSwf).clear();
+                }
+            }
+        }
+        for (DebuggerHandler.ConnectionListener l : handler.getConnectionListeners()) {
+            l.disconnected(DebuggerSession.this);
+        }
+        debuggedSwfs.clear();
+    }
+
+    public void disconnect() {
+        frame = null;
+        pool = null;
+        breakInfo = null;
+        breakReason = null;
+        connected = false;
+        if (commands != null) {
+            commands.disconnect();
+        }
+        disconnected();
+    }
+
+    public synchronized boolean isConnected() {
+        return connected;
+    }
+
+    public DebuggerCommands getCommands() throws IOException {
+        if (!isConnected() || commands == null) {
+            throw new IOException("Not connected");
+        }
+        return commands;
+    }
+
+    private void sendBreakPoints() throws IOException {
+        if (!isConnected()) {
+            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "not sending bps, not connected");
+            return;
+        }
+        synchronized (this) {
+            Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "sending breakpoints of {0} swfs", debuggedSwfs.size());
+            for (int swfIndex = 0; swfIndex < debuggedSwfs.size(); swfIndex++) {
+                if (!swfIndicesCommitted.contains(swfIndex)) {
+                    continue;
+                }
+                SWF debuggedSwf = debuggedSwfs.get(swfIndex);
+                String hash = swfIndex == 0 ? "main" : Main.getSwfHash(debuggedSwf); //??
+
+                Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "sending breakpoints of {0}", hash);
+
+                if (toRemoveBPointMap.containsKey(debuggedSwf)) {
+                    for (String scriptName : toRemoveBPointMap.get(debuggedSwf).keySet()) {
+                        if (scriptName.startsWith("#PCODE") != Main.isDebugPCode()) {
+                            continue;
+                        }
+                        int file = moduleIdOf(hash + ":" + scriptName);
+                        if (file > -1) {
+                            for (int line : toRemoveBPointMap.get(debuggedSwf).get(scriptName)) {
+                                if (isBreakpointConfirmed(debuggedSwf, scriptName, line)) {
+                                    commands.removeBreakPoint(file, line);
+                                    confirmedPointMap.get(debuggedSwf).get(scriptName).remove(line);
+                                    if (confirmedPointMap.get(debuggedSwf).get(scriptName).isEmpty()) {
+                                        confirmedPointMap.get(debuggedSwf).remove(scriptName);
+                                    }
+                                }
+                                Logger.getLogger(DebuggerSession.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} removed", new Object[]{scriptName, line});
+                            }
+                        }
+                    }
+                    toRemoveBPointMap.get(debuggedSwf).clear();
+                    if (toRemoveBPointMap.get(debuggedSwf).isEmpty()) {
+                        toRemoveBPointMap.remove(debuggedSwf);
+                    }
+                }
+
+                if (toAddBPointMap.containsKey(debuggedSwf)) {
+                    Set<String> toAddScripts = new HashSet<>(toAddBPointMap.get(debuggedSwf).keySet());
+                    for (String scriptName : toAddScripts) {
+                        if (scriptName.startsWith("#PCODE") != Main.isDebugPCode()) {
+                            continue;
+                        }
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "searching for module of {0}:{1}", new Object[]{hash, scriptName});
+                        int file = moduleIdOf(hash + ":" + scriptName);
+                        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "module = {0}", file);
+                        if (file > -1) {
+                            Set<Integer> lines = new HashSet<>(toAddBPointMap.get(debuggedSwf).get(scriptName));
+                            for (int line : lines) {
+                                if (commands.addBreakPoint(file, line)) {
+                                    Logger.getLogger(DebuggerSession.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} submitted successfully", new Object[]{scriptName, line});
+                                    markBreakPointConfirmed(debuggedSwf, scriptName, line);
+                                    markBreakPointValid(debuggedSwf, scriptName, line);
+                                    toAddBPointMap.get(debuggedSwf).get(scriptName).remove(line);
+                                    if (toAddBPointMap.get(debuggedSwf).get(scriptName).isEmpty()) {
+                                        toAddBPointMap.get(debuggedSwf).remove(scriptName);
+                                    }
+                                    if (toAddBPointMap.get(debuggedSwf).isEmpty()) {
+                                        toAddBPointMap.remove(debuggedSwf);
+                                    }
+                                } else {
+                                    Logger.getLogger(DebuggerSession.class.getName()).log(Level.INFO, "Breakpoint {0}:{1} unable to submit", new Object[]{scriptName, line});
+                                    markBreakPointInvalid(debuggedSwf, scriptName, line);
+                                }
+                            }
+                        } else {
+                            for (int line : toAddBPointMap.get(debuggedSwf).get(scriptName)) {
+                                markBreakPointInvalid(debuggedSwf, scriptName, line);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Logger.getLogger(DebuggerSession.class.getName()).log(Level.FINEST, "sending bps finished");
+
+    }
+
+    public synchronized InConstantPool getConstantPool() {
+        if (!paused) {
+            return null;
+        }
+        return pool;
+    }
+
+    public synchronized InCallFunction callMethod(Variable object, String methodName, List<Object> args) throws DebuggerHandler.ActionScriptException {
+        return callFunction(false, methodName, object, args);
+    }
+
+    public synchronized InCallFunction callMethod(String object, String methodName, List<Object> args) throws DebuggerHandler.ActionScriptException {
+        InGetVariable igv = getVariable(0, object, false, false);
+        return callMethod(igv.parent, methodName, args);
+    }
+
+    private static String typeAsStr(Object value) {
+        if (value == null) {
+            return "null";
+        }
+        if ((value instanceof Long) || (value instanceof Integer)) {
+            return "int";
+        }
+        if (value instanceof Number) {
+            return "Number";
+        }
+        if (value instanceof String) {
+            return "String";
+        }
+        if (value instanceof Variable) {
+            Variable v = (Variable) value;
+            return v.getTypeAsStr();
+        }
+        return "String";
+    }
+
+    private static String valueAsStr(Object value) {
+        if (value == null) {
+            return "null";
+        }
+        if (value instanceof Double) {
+            double doubleValue = ((Double) value).doubleValue();
+            long longValue = (long) doubleValue;
+            if (doubleValue == longValue) {
+                return Long.toString(longValue);
+            }
+        }
+
+        if (value instanceof Variable) {
+            Variable v = (Variable) value;
+            return valueAsStr(v.value);
+        }
+        return "" + value;
+    }
+
+    public synchronized InCallFunction callFunction(boolean isConstructor, String funcName, Variable thisValue, List<Object> args) throws DebuggerHandler.ActionScriptException {
+        List<String> argTypes = new ArrayList<>();
+        List<String> argValues = new ArrayList<>();
+        for (Object value : args) {
+            argTypes.add(typeAsStr(value));
+            argValues.add(valueAsStr(value));
+        }
+        String thisType = typeAsStr(thisValue);
+        String thisValueStr = valueAsStr(thisValue);
+        try {
+            InCallFunction icf = commands.callFunction(isConstructor, funcName, thisType, thisValueStr, argTypes, argValues);
+            if (!icf.variables.isEmpty()) {
+                if ((icf.variables.get(0).flags & VariableFlags.IS_EXCEPTION) > 0) {
+                    throw new DebuggerHandler.ActionScriptException("" + icf.variables.get(0).value);
+                }
+            }
+            return icf;
+        } catch (IOException e) {
+            //ignored
+        }
+        return null;
+    }
+
+    public Map<String, Long> getPlacedObjects() {
+        return new LinkedHashMap<>(placedObjects);
+    }
+
+    @Override
+    public String toString() {
+        return "[s:" + id + "]";
+    }        
+}
diff --git a/src/com/jpexs/decompiler/flash/gui/Main.java b/src/com/jpexs/decompiler/flash/gui/Main.java
index dd517e90f..7752523bf 100644
--- a/src/com/jpexs/decompiler/flash/gui/Main.java
+++ b/src/com/jpexs/decompiler/flash/gui/Main.java
@@ -105,6 +105,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
 import java.net.InetSocketAddress;
 import java.net.Proxy;
@@ -231,49 +232,60 @@ public class Main {
     public static String currentDebuggerPackage = null;
 
     private static SWF runningSWF = null;
-    
+
     private static SWF debuggedSWF = null;
 
     private static String preparedHashSha256 = null;
-    
+
     private static SwfPreparation runningPreparation = null;
-    
+
     private static boolean loggingFileLoaded = false;
-    
+
     private static boolean debugListening = false;
 
     public static SWF getDebuggedSWF() {
         return debuggedSWF;
     }
-    
-    
-    public static void findDebuggedSwf(String hashSha256) {
-        
-        System.err.println("Searching for hash " + hashSha256 + "...");
-        
+
+    public static void setDebuggedSWF(SWF swf) {
+        debuggedSWF = swf;
+    }
+
+    /**
+     * Searches opened swfs for swf with sha256 hash of its decompressed form
+     *
+     * @param hashSha256 Hex sha 256
+     * @return SWF or null if not found
+     */
+    public static SWF findOpenedSwfByHash(String hashSha256) {
+        Logger.getLogger(Main.class.getName()).log(Level.FINE, "Searching for hash {0}...", hashSha256);
+
         for (SWF swf : mainFrame.getPanel().getAllSwfs()) {
-            System.err.println("Checking " + swf +" with hash " + swf.getHashSha256());
+            Logger.getLogger(Main.class.getName()).log(Level.FINE, "Checking {0} with hash {1}", new Object[]{swf.toString(), swf.getHashSha256()});
             if (Objects.equals(hashSha256, swf.getHashSha256())) {
-                Main.debuggedSWF = swf;
-                System.err.println("RECEIVED SWF FOUND");
-                return;
+                Logger.getLogger(Main.class.getName()).log(Level.FINE, "RECEIVED SWF FOUND");
+                return swf;
             }
         }
-                
+
         if (preparedHashSha256 != null && hashSha256.equals(preparedHashSha256)) {
-            System.err.println("RECEIVED SWF IS ONE THAT WAS PREPARED FOR RUN...");
-            Main.debuggedSWF = runningSWF;
-            return;
+            Logger.getLogger(Main.class.getName()).log(Level.FINE, "RECEIVED SWF IS ONE THAT WAS PREPARED FOR RUN...");
+            return runningSWF;
         }
-        
-        System.err.println("RECEIVED SWF IS NOT ANY OF OURS");
-        Main.debuggedSWF = null;
+
+        Logger.getLogger(Main.class.getName()).log(Level.FINE, "RECEIVED SWF IS NOT ANY OF OURS");
+        return null;
     }
-    
+
     public static SWF getRunningSWF() {
         //System.err.println("debuggedSWF: " + (debuggedSWF == null ? "NOT SET" : debuggedSWF));
         //return runningSWF;
-        return debuggedSWF;
+        //return debuggedSWF;
+        DebuggerSession session = getCurrentDebugSession();
+        if (session != null) {
+            return session.getDebuggedSwfs().get(0);
+        }
+        return null;
     }
 
     public static WatchService getWatcher() {
@@ -331,12 +343,16 @@ public class Main {
             mainFrame.getPanel().clearDebuggerColors();
         }
         if (runProcessDebug) {
-            Main.getDebugHandler().disconnect();
+            Main.getDebugHandler().terminateAllSessions();
         }
     }
 
     public static synchronized boolean isDebugPaused() {
-        return (runProcess != null && runProcessDebug || !flashDebugger.isStopped()) && getDebugHandler().isPaused();
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return false;
+        }
+        return (runProcess != null && runProcessDebug || !flashDebugger.isStopped()) && session.isPaused();
     }
 
     public static synchronized boolean isDebugRunning() {
@@ -348,60 +364,60 @@ public class Main {
     }
 
     public static synchronized boolean isDebugConnected() {
-        return getDebugHandler().isConnected();
+        return getDebugHandler().isAnySessionConnected();
     }
 
     public static synchronized boolean isRunning() {
         return runProcess != null && !runProcessDebug;
     }
 
-    public static synchronized void debugExportByteArray(Variable v, OutputStream os) throws IOException {
+    public static synchronized void debugExportByteArray(DebuggerSession session, Variable v, OutputStream os) throws IOException {
         try {
             long objectId = 0L;
             if ((v.vType == VariableType.OBJECT || v.vType == VariableType.MOVIECLIP)) {
                 objectId = (Long) v.value;
             }
-            Object oldPos = getDebugHandler().getVariable(objectId, "position", false, true).parent.value;
-            getDebugHandler().setVariable(objectId, "position", VariableType.NUMBER, 0);
-            int length = (int) (double) (Double) getDebugHandler().getVariable(objectId, "length", false, true).parent.value;
+            Object oldPos = session.getVariable(objectId, "position", false, true).parent.value;
+            session.setVariable(objectId, "position", VariableType.NUMBER, 0);
+            int length = (int) (double) (Double) session.getVariable(objectId, "length", false, true).parent.value;
 
             for (int i = 0; i < length; i++) {
-                int b = (int) (double) (Double) getDebugHandler().callFunction(false, "readByte", v, new ArrayList<>()).variables.get(0).value;
+                int b = (int) (double) (Double) session.callFunction(false, "readByte", v, new ArrayList<>()).variables.get(0).value;
                 os.write(b);
             }
-            getDebugHandler().setVariable(objectId, "position", VariableType.NUMBER, oldPos);
+            session.setVariable(objectId, "position", VariableType.NUMBER, oldPos);
         } catch (DebuggerHandler.ActionScriptException ex) {
             Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
         }
     }
 
-    public static synchronized void debugImportByteArray(Variable v, InputStream is) throws IOException {
+    public static synchronized void debugImportByteArray(DebuggerSession session, Variable v, InputStream is) throws IOException {
         try {
             long objectId = 0L;
             if ((v.vType == VariableType.OBJECT || v.vType == VariableType.MOVIECLIP)) {
                 objectId = (Long) v.value;
             }
-            Double oldPos = (Double) getDebugHandler().getVariable(objectId, "position", false, true).parent.value;
-            getDebugHandler().setVariable(objectId, "length", VariableType.NUMBER, 0);
-            getDebugHandler().setVariable(objectId, "position", VariableType.NUMBER, 0);
+            Double oldPos = (Double) session.getVariable(objectId, "position", false, true).parent.value;
+            session.setVariable(objectId, "length", VariableType.NUMBER, 0);
+            session.setVariable(objectId, "position", VariableType.NUMBER, 0);
 
             int length = 0;
             int b;
             while ((b = is.read()) > -1) {
-                getDebugHandler().callFunction(false, "writeByte", v, Arrays.asList((Double) (double) b));
+                session.callFunction(false, "writeByte", v, Arrays.asList((Double) (double) b));
                 length++;
             }
             if (oldPos > length) {
                 oldPos = (Double) (double) length;
             }
-            getDebugHandler().setVariable(objectId, "position", VariableType.NUMBER, oldPos);
+            session.setVariable(objectId, "position", VariableType.NUMBER, oldPos);
         } catch (DebuggerHandler.ActionScriptException ex) {
             Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
         }
     }
 
-    public static synchronized boolean addWatch(Variable v, long v_id, boolean watchRead, boolean watchWrite) {
-        DebuggerCommands.Watch w = getDebugHandler().addWatch(v, v_id, watchRead, watchWrite);
+    public static synchronized boolean addWatch(DebuggerSession session, Variable v, long v_id, boolean watchRead, boolean watchWrite) {
+        DebuggerCommands.Watch w = session.addWatch(v, v_id, watchRead, watchWrite);
         return w != null;
     }
 
@@ -591,9 +607,9 @@ public class Main {
                         });
                         startWork(AppStrings.translate("work.generating_swd"), swfPrepareWorker, true);
                         if (doPCode) {
-                            instrSWF.generatePCodeSwdFile(swdFile, getPackBreakPoints(true, swfHash), swfHash);
+                            instrSWF.generatePCodeSwdFile(swdFile, getAllSessionPackBreakPoints(swfHash), swfHash);
                         } else {
-                            instrSWF.generateSwdFile(swdFile, getPackBreakPoints(true, swfHash), swfHash);
+                            instrSWF.generateSwdFile(swdFile, getAllSessionPackBreakPoints(swfHash), swfHash);
                         }
                         tempFiles.add(swdFile);
                     }
@@ -647,12 +663,12 @@ public class Main {
             try (FileOutputStream fos = new FileOutputStream(toPrepareFile)) {
                 instrSWF.saveTo(fos);
             }
-            if ("main".equals(swfHash)) {            
+            if ("main".equals(swfHash)) {
                 preparedHashSha256 = instrSWF.getHashSha256();
-            }  
-        }                  
+            }
+        }
     }
-    
+
     public static void prepareForDebug(SWF swf, File fTempFile, File tempRunDir, List<File> tempFiles, boolean doPCode) throws IOException, InterruptedException {
         SWF swfToSave = swf;
         if (swf.gfx) {
@@ -661,9 +677,9 @@ public class Main {
         try (OutputStream fos = new BufferedOutputStream(new FileOutputStream(fTempFile))) {
             swfToSave.saveTo(fos, false, swf.gfx);
         }
-        prepareSwf("main", new SwfDebugPrepare(doPCode), fTempFile, swf.getFile() == null ? null : new File(swf.getFile()), tempRunDir, tempFiles);                    
+        prepareSwf("main", new SwfDebugPrepare(doPCode), fTempFile, swf.getFile() == null ? null : new File(swf.getFile()), tempRunDir, tempFiles);
     }
-    
+
     private static File createTempFileInDir(File tempFilesDir, String prefix, String suffix) throws IOException {
         if (tempFilesDir == null || !tempFilesDir.isDirectory()) {
             return File.createTempFile(prefix, suffix);
@@ -847,10 +863,10 @@ public class Main {
         Main.startWork(AppStrings.translate("work.debugging.start") + "...", null, true);
         Main.startDebugger();
         Main.startWork(AppStrings.translate("work.debugging.listening"), null);
-        mainFrame.getMenu().hilightPath("/debugging");        
+        mainFrame.getMenu().hilightPath("/debugging");
     }
-    
-    public static void runDebug(SWF swf, final boolean doPCode) {        
+
+    public static void runDebug(SWF swf, final boolean doPCode) {
         String flashVars = ""; //key=val&key2=val2
         String playerLocation = Configuration.playerDebugLocation.get();
         if (playerLocation.isEmpty() || (!new File(playerLocation).exists())) {
@@ -861,7 +877,7 @@ public class Main {
         if (swf == null) {
             return;
         }
-        debugHandler.setMainDebuggedSwf(swf);
+        //debugHandler.setMainDebuggedSwf(swf); ???
         File tempRunDir = swf.getFile() == null ? null : new File(swf.getFile()).getParentFile();
         File tempFile = null;
 
@@ -930,61 +946,121 @@ public class Main {
     }
 
     public static synchronized int getIp(Object pack) {
-        return getDebugHandler().getBreakIp();
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return -1;
+        }
+        return session.getBreakIp();
     }
 
     public static synchronized String getIpClass() {
-        return getDebugHandler().getBreakScriptName();
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return null;
+        }
+        return session.getBreakScriptName();
     }
 
     public static synchronized List<Integer> getStackLines() {
-        return getDebugHandler().getStackLines();
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return new ArrayList<>();
+        }
+        return session.getStackLines();
     }
 
     public static synchronized List<String> getStackClasses() {
-        return getDebugHandler().getStackScripts();
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return new ArrayList<>();
+        }
+        return session.getStackScripts();
     }
 
     public static synchronized boolean isBreakPointValid(String scriptName, int line) {
+        DebuggerSession session = getCurrentDebugSession();
+        if (session == null) {
+            return true;
+        }
         SWF swf = getMainFrame().getPanel().getCurrentSwf();
-        return !getDebugHandler().isBreakpointInvalid(swf, scriptName, line);
+        return !session.isBreakpointInvalid(swf, scriptName, line);
     }
 
-    public static synchronized void addBreakPoint(String scriptName, int line) {
+    public static synchronized void addBreakPoint(DebuggerSession session, String scriptName, int line) {
         SWF swf = getMainFrame().getPanel().getCurrentSwf();
-        getDebugHandler().addBreakPoint(swf, scriptName, line);
+        session.addBreakPoint(swf, scriptName, line);
     }
 
-    public static synchronized void removeBreakPoint(String scriptName, int line) {
+    public static synchronized void removeBreakPoint(DebuggerSession session, String scriptName, int line) {
         SWF swf = getMainFrame().getPanel().getCurrentSwf();
-        getDebugHandler().removeBreakPoint(swf, scriptName, line);
+        session.removeBreakPoint(swf, scriptName, line);
     }
 
     public static synchronized boolean toggleBreakPoint(String scriptName, int line) {
         SWF swf = getMainFrame().getPanel().getCurrentSwf();
-        if (getDebugHandler().isBreakpointToAdd(swf, scriptName, line) || getDebugHandler().isBreakpointConfirmed(swf, scriptName, line) || getDebugHandler().isBreakpointInvalid(swf, scriptName, line)) {
+        Map<String, Set<Integer>> breakPoints = getDebugHandler().getAllSessionsBreakPoints(swf);
+
+        if (breakPoints.containsKey(scriptName) && breakPoints.get(scriptName).contains(line)) {
             getDebugHandler().removeBreakPoint(swf, scriptName, line);
             return false;
-        } else {
-            getDebugHandler().addBreakPoint(swf, scriptName, line);
-            return true;
         }
+
+        getDebugHandler().addBreakPoint(swf, scriptName, line);
+        return true;
+
+        /*if (session.isBreakpointToAdd(swf, scriptName, line) || session.isBreakpointConfirmed(swf, scriptName, line) || session.isBreakpointInvalid(swf, scriptName, line)) {
+            session.removeBreakPoint(swf, scriptName, line);
+            return false;
+        } else {
+            session.addBreakPoint(swf, scriptName, line);
+            return true;
+        }*/
     }
 
-    public static synchronized Map<String, Set<Integer>> getPackBreakPoints(boolean validOnly, String swfHash) {
+    public static synchronized Map<String, Set<Integer>> getAllSessionPackBreakPoints(String swfHash) {
         SWF swf = Main.getSwfByHash(swfHash);
-        return getDebugHandler().getAllBreakPoints(swf, validOnly);
+        return getDebugHandler().getAllSessionsBreakPoints(swf);
     }
 
-    public static synchronized Set<Integer> getScriptBreakPoints(String pack, boolean onlyValid) {
+    public static synchronized Map<String, Set<Integer>> getPackBreakPoints(DebuggerSession session, boolean validOnly, String swfHash) {
+        SWF swf = Main.getSwfByHash(swfHash);
+        return session.getAllBreakPoints(swf, validOnly);
+    }
+
+    public static synchronized Set<Integer> getScriptBreakPoints(String pack) {
         SWF swf = getMainFrame().getPanel().getCurrentSwf();
-        return getDebugHandler().getBreakPoints(swf, pack, onlyValid);
+        return getDebugHandler().getAllSessionsScriptBreakPoints(swf, pack);
     }
 
     public static DebuggerHandler getDebugHandler() {
         return debugHandler;
     }
 
+    public static DebuggerSession getCurrentDebugSession() {
+        if (mainFrame == null) {
+            return null;
+        }
+        if (mainFrame.getPanel() == null) {
+            return null;
+        }
+        SWF currentSwf = mainFrame.getPanel().getCurrentSwf();
+        if (currentSwf == null) {
+            return null;
+        }
+        return getDebugHandler().getSessionContainingSwf(currentSwf);
+    }
+    
+    public static void updateSession() {
+        DebuggerSession session = getCurrentDebugSession();
+        for (DebuggerHandler.FrameChangeListener l : getDebugHandler().getFrameChangeListeners()) {
+            l.frameChanged(session);
+        }
+        
+        if (getDebugHandler().getNumberOfPausedSessions() > 0) {
+            mainFrame.getPanel().showDebugStackFrame();
+        }
+    }
+
     public static void ensureMainFrame() {
         if (mainFrame == null) {
             synchronized (Main.class) {
@@ -1027,8 +1103,8 @@ public class Main {
         loadFromMemoryFrame.setVisible(true);
     }
 
-    public static void setVariable(long parentId, String varName, int valueType, Object value) {
-        getDebugHandler().setVariable(parentId, varName, valueType, value);
+    public static void setVariable(DebuggerSession session, long parentId, String varName, int valueType, Object value) {
+        session.setVariable(parentId, varName, valueType, value);
     }
 
     public static void setSubLimiter(boolean value) {
@@ -1100,7 +1176,7 @@ public class Main {
     public static void startWork(final String name, final int percent, final CancellableWorker worker, boolean force) {
         working = true;
         long nowTime = System.currentTimeMillis();
-        if (mainFrame != null && nowTime < lastTimeStartWork + 1000) {
+        if (!force && mainFrame != null && nowTime < lastTimeStartWork + 1000) {
             mainFrame.getPanel().setWorkStatusHidden(name, worker);
             return;
         }
@@ -1117,7 +1193,7 @@ public class Main {
             if (loadingDialog != null) {
                 loadingDialog.setDetail(name);
                 loadingDialog.setPercent(percent);
-            }            
+            }
         });
         if (CommandLineArgumentParser.isCommandLineMode()) {
             System.out.println(name);
@@ -1470,7 +1546,7 @@ public class Main {
                                                 }
                                             };
                                             fc.addChoosableFileFilter(swtFilter);
-                                            
+
                                             FileFilter gfxFilter = new FileFilter() {
                                                 @Override
                                                 public boolean accept(File f) {
@@ -1767,7 +1843,7 @@ public class Main {
         private final OpenableOpened executeAfterOpen;
 
         private final int[] reloadIndices;
-        
+
         private final boolean loadSession;
 
         public OpenFileWorker(OpenableSourceInfo sourceInfo, boolean loadSession) {
@@ -1891,6 +1967,14 @@ public class Main {
                                     }
                                 }
                             }
+                            List<String> breakpointsList = conf.getCustomDataAsList(CustomConfigurationKeys.KEY_BREAKPOINTS);
+                            for (String breakpoint : breakpointsList) {
+                                if (breakpoint.matches("^.*:[0-9]+$")) {
+                                    int line = Integer.parseInt(breakpoint.substring(breakpoint.lastIndexOf(":") + 1));
+                                    String scriptName = breakpoint.substring(0, breakpoint.lastIndexOf(":"));
+                                    getDebugHandler().addBreakPoint(swf, scriptName, line);
+                                }
+                            }
                         }
                     }
                 }
@@ -1901,7 +1985,7 @@ public class Main {
             View.execInEventDispatch(() -> {
                 if (mainFrame == null) {
                     ensureMainFrame();
-                    Main.startWork(AppStrings.translate("work.creatingwindow") + "...", null);                    
+                    Main.startWork(AppStrings.translate("work.creatingwindow") + "...", null);
                 }
                 loadingDialog.setVisible(false);
 
@@ -1926,14 +2010,6 @@ public class Main {
                     if (swfCustomConf != null) {
                         resourcesPathStr = swfCustomConf.getCustomData(CustomConfigurationKeys.KEY_LAST_SELECTED_PATH_RESOURCES, resourcesPathStr);
                         tagListPathStr = swfCustomConf.getCustomData(CustomConfigurationKeys.KEY_LAST_SELECTED_PATH_TAGLIST, null);
-                        List<String> breakpointsList = swfCustomConf.getCustomDataAsList(CustomConfigurationKeys.KEY_BREAKPOINTS);
-                        for (String breakpoint : breakpointsList) {
-                            if (breakpoint.matches("^.*:[0-9]+$")) {
-                                int line = Integer.parseInt(breakpoint.substring(breakpoint.lastIndexOf(":") + 1));
-                                String scriptName = breakpoint.substring(0, breakpoint.lastIndexOf(":"));
-                                getDebugHandler().addBreakPoint(fswf, scriptName, line);
-                            }
-                        }
                     }
 
                     if (loadSession) {
@@ -1954,7 +2030,7 @@ public class Main {
                                     mainFrame.getPanel().tagListTree.setSelectionPath(tp);
                                 }
                             } else {
-                                mainFrame.getPanel().tagListTree.setSelectionPathString(tagListPathStr);                        
+                                mainFrame.getPanel().tagListTree.setSelectionPathString(tagListPathStr);
                             }
                         } else {
                             mainFrame.getPanel().tagTree.setExpandPathString(resourcesPathStr);
@@ -2108,7 +2184,7 @@ public class Main {
                         executeAfterOpen.run();
                     }
                 }
-            }, loadSession  
+            }, loadSession
             );
             return openResult;
         } catch (IOException ex) {
@@ -2139,7 +2215,7 @@ public class Main {
 
         return openFile(new OpenableSourceInfo[]{sourceInfo}, executeAfterOpen, new int[]{reloadIndex}, loadSession);
     }
-    
+
     public static OpenFileResult openFile(OpenableSourceInfo[] newSourceInfos) {
         View.checkAccess();
 
@@ -2298,7 +2374,7 @@ public class Main {
             }
             fc.setSelectedFile(fc.getCurrentDirectory().toPath().resolve(fileTitle).toFile());
         }
-        
+
         FileFilter swcFilter = new FileFilter() {
             @Override
             public boolean accept(File f) {
@@ -2312,31 +2388,31 @@ public class Main {
             }
         };
         fc.setFileFilter(swcFilter);
-        
-        if (fc.showSaveDialog(getDefaultMessagesComponent()) != JFileChooser.APPROVE_OPTION) {        
+
+        if (fc.showSaveDialog(getDefaultMessagesComponent()) != JFileChooser.APPROVE_OPTION) {
             return false;
         }
         File file = Helper.fixDialogFile(fc.getSelectedFile());
         String fileName = file.getAbsolutePath();
-        
+
         if (!fileName.toLowerCase(Locale.ENGLISH).endsWith(".swc")) {
             fileName += ".swc";
-        }               
-        
+        }
+
         SwfToSwcExporter exporter = new SwfToSwcExporter();
         try {
             exporter.exportSwf(swf, new File(fileName), false);
         } catch (IOException iex) {
             ViewMessages.showMessageDialog(getDefaultMessagesComponent(), iex.getMessage(), AppStrings.translate("error"), JOptionPane.ERROR_MESSAGE);
             return false;
-        } catch (InterruptedException ex) {           
+        } catch (InterruptedException ex) {
             return false;
         }
-        
+
         Configuration.lastSaveDir.set(file.getParentFile().getAbsolutePath());
         return true;
     }
-    
+
     public static boolean saveFileDialog(Openable openable, final SaveFileMode mode) {
 
         String ext = ".swf";
@@ -2387,7 +2463,7 @@ public class Main {
                 return AppStrings.translate("filter.swt");
             }
         };
-        
+
         FileFilter gfxFilter = new FileFilter() {
             @Override
             public boolean accept(File f) {
@@ -2492,14 +2568,14 @@ public class Main {
         } else if (openable instanceof SWF) {
             SWF swf = (SWF) openable;
             if (swf.getFile() != null && swf.getFile().toLowerCase(Locale.ENGLISH).endsWith(".swt")) {
-                fc.setFileFilter(swtFilter);   
+                fc.setFileFilter(swtFilter);
                 fc.addChoosableFileFilter(swfFilter);
             } else {
-                fc.setFileFilter(swfFilter);   
+                fc.setFileFilter(swfFilter);
                 fc.addChoosableFileFilter(swtFilter);
             }
             fc.addChoosableFileFilter(gfxFilter);
-            
+
         } else if (openable instanceof ABC) {
             fc.setFileFilter(abcFilter);
         }
@@ -2523,7 +2599,7 @@ public class Main {
                     }
                     ((SWF) openable).gfx = true;
                 }
-                
+
                 if (selFilter == swtFilter) {
                     if (!fileName.toLowerCase(Locale.ENGLISH).endsWith(".swt")) {
                         fileName += ".swt";
@@ -2662,7 +2738,7 @@ public class Main {
             }
         };
         fc.addChoosableFileFilter(swtFilter);
-        
+
         FileFilter swcFilter = new FileFilter() {
             @Override
             public boolean accept(File f) {
@@ -2805,7 +2881,7 @@ public class Main {
         initUiLang();
 
         initLookAndFeel();
-                
+
         View.execInEventDispatch(() -> {
             ErrorLogFrame.createNewInstance();
 
@@ -2976,13 +3052,15 @@ public class Main {
                 flashDebugger = new Debugger();
                 debugHandler = new DebuggerHandler();
                 debugHandler.addBreakListener(new DebuggerHandler.BreakListener() {
+                    
                     @Override
-                    public void doContinue() {
+                    public void doContinue(DebuggerSession session) {
                         mainFrame.getPanel().clearDebuggerColors();
+                        mainFrame.getMenu().updateComponents();
                     }
 
                     @Override
-                    public void breakAt(String scriptName, int line, final int classIndex, final int traitIndex, final int methodIndex) {
+                    public void breakAt(DebuggerSession session, String scriptName, int line, final int classIndex, final int traitIndex, final int methodIndex) {
                         View.execInEventDispatch(new Runnable() {
                             @Override
                             public void run() {
@@ -2992,7 +3070,17 @@ public class Main {
                                     hash = scriptName.substring(0, scriptName.indexOf(":"));
                                     scriptNameNoHash = scriptName.substring(scriptName.indexOf(":") + 1);
                                 }
-                                SWF swf = Main.getSwfByHash(hash);
+                                SWF swf = "main".equals(hash) ? session.getDebuggedSwfs().get(0) : Main.getSwfByHash(hash);
+                                Logger.getLogger(Main.class.getName()).log(Level.FINE, "Break. Current session: {0}, New break session: {1}", new Object[]{Main.getCurrentDebugSession(), session});
+                                    
+                                if (
+                                        Main.getDebugHandler().getNumberOfPausedSessions() > 1
+                                        && Main.getCurrentDebugSession() != session
+                                    ) {
+                                    Logger.getLogger(Main.class.getName()).log(Level.INFO, "Another SWF ({0}) has reached breakpoint meanwhile", swf.toString());
+                                    mainFrame.getPanel().refreshBreakPoints();
+                                    return;
+                                }
                                 mainFrame.getPanel().gotoScriptLine(swf, scriptNameNoHash, line, classIndex, traitIndex, methodIndex, Main.isDebugPCode());
                             }
                         });
@@ -3000,12 +3088,12 @@ public class Main {
                 });
                 debugHandler.addConnectionListener(new DebuggerHandler.ConnectionListener() {
                     @Override
-                    public void connected() {
+                    public void connected(DebuggerSession session) {
                         Main.mainFrame.getMenu().updateComponents();
                     }
 
                     @Override
-                    public void disconnected() {
+                    public void disconnected(DebuggerSession session) {
                         if (Main.mainFrame != null) {
                             Main.mainFrame.getMenu().updateComponents();
                         }
@@ -3028,10 +3116,11 @@ public class Main {
     }
 
     public static void startDebugger() {
-        flashDebugger.startDebugger();        
+        flashDebugger.startDebugger();
     }
 
     public static void stopDebugger() {
+        getDebugHandler().terminateAllSessions();
         flashDebugger.stopDebugger();
     }
 
@@ -3288,7 +3377,7 @@ public class Main {
         AppStrings.updateLanguage();
 
         Helper.decompilationErrorAdd = AppStrings.translate(Configuration.autoDeobfuscate.get() ? "deobfuscation.comment.failed" : "deobfuscation.comment.tryenable");
-        
+
         ResourceBundle advancedSettingsBundle = ResourceBundle.getBundle(AppStrings.getResourcePath(AdvancedSettingsDialog.class));
         Set<String> configurationNames = Configuration.getConfigurationFields(false, true).keySet();
         Map<String, String> titles = new LinkedHashMap<>();
@@ -3298,7 +3387,7 @@ public class Main {
                 titles.put(name, advancedSettingsBundle.getString("config.name." + name));
             }
             if (advancedSettingsBundle.containsKey("config.description." + name)) {
-                descriptions.put(name, advancedSettingsBundle.getString("config.description." + name));            
+                descriptions.put(name, advancedSettingsBundle.getString("config.description." + name));
             }
         }
         Configuration.setConfigurationDescriptions(descriptions);
@@ -3358,11 +3447,11 @@ public class Main {
      */
     public static void main(String[] args) throws IOException {
         decodeLaunch5jArgs(args);
-        preInitLogging();        
+        preInitLogging();
         setSessionLoaded(false);
 
-        System.setProperty("sun.io.serialization.extendedDebugInfo", "true");       
-        
+        System.setProperty("sun.io.serialization.extendedDebugInfo", "true");
+
         clearTemp();
 
         try {
@@ -3638,17 +3727,17 @@ public class Main {
         if (!showStable && !showNightly) {
             return false;
         }
-                
+
         String stableTagName = "version" + ApplicationInfo.version_major + "." + ApplicationInfo.version_minor + "." + ApplicationInfo.version_release;
         String ignoreVersion = "-";
-        
+
         String currentTagName;
         if (ApplicationInfo.nightly) {
             currentTagName = "nightly" + ApplicationInfo.version_build;
         } else {
             currentTagName = stableTagName;
         }
-        
+
         if (!showNightly) {
             //prereleases are not shown as latest, when checking latest nightly, this is useless
             JsonValue latestVersionInfoJson = urlGetJson(ApplicationInfo.GITHUB_RELEASES_LATEST_URL);
@@ -3799,7 +3888,7 @@ public class Main {
             }
         }
     }
-    
+
     public static void initLogging(boolean debug) {
         if (loggingFileLoaded) {
             return;
diff --git a/src/com/jpexs/decompiler/flash/gui/MainFrameMenu.java b/src/com/jpexs/decompiler/flash/gui/MainFrameMenu.java
index 00ab47b70..0df223f68 100644
--- a/src/com/jpexs/decompiler/flash/gui/MainFrameMenu.java
+++ b/src/com/jpexs/decompiler/flash/gui/MainFrameMenu.java
@@ -1756,11 +1756,11 @@ public abstract class MainFrameMenu implements MenuBuilder {
 
     public boolean pauseActionPerformed(ActionEvent evt) {
         try {
-            DebuggerCommands cmd = Main.getDebugHandler().getCommands();
+            DebuggerCommands cmd = Main.getCurrentDebugSession().getCommands();
             //TODO
 
         } catch (IOException ex) {
-            Main.getDebugHandler().disconnect();
+            Main.getCurrentDebugSession().disconnect();
             //ignore
         }
         return true;
@@ -1770,13 +1770,13 @@ public abstract class MainFrameMenu implements MenuBuilder {
 
         try {
 
-            DebuggerCommands cmd = Main.getDebugHandler().getCommands();
+            DebuggerCommands cmd = Main.getCurrentDebugSession().getCommands();
             mainFrame.getPanel().clearDebuggerColors();
             Main.startWork(AppStrings.translate("work.debugging") + "...", null);
 
             cmd.stepOver();
         } catch (IOException ex) {
-            Main.getDebugHandler().disconnect();
+            Main.getCurrentDebugSession().disconnect();
             //ignore
         }
         return true;
@@ -1784,13 +1784,13 @@ public abstract class MainFrameMenu implements MenuBuilder {
 
     public boolean stepIntoActionPerformed(ActionEvent evt) {
         try {
-            DebuggerCommands cmd = Main.getDebugHandler().getCommands();
+            DebuggerCommands cmd = Main.getCurrentDebugSession().getCommands();
             mainFrame.getPanel().clearDebuggerColors();
             Main.startWork(AppStrings.translate("work.debugging") + "...", null);
 
             cmd.stepInto();
         } catch (IOException ex) {
-            Main.getDebugHandler().disconnect();
+            Main.getCurrentDebugSession().disconnect();
             //ignore
         }
 
@@ -1799,12 +1799,12 @@ public abstract class MainFrameMenu implements MenuBuilder {
 
     public boolean stepOutActionPerformed(ActionEvent evt) {
         try {
-            DebuggerCommands cmd = Main.getDebugHandler().getCommands();
+            DebuggerCommands cmd = Main.getCurrentDebugSession().getCommands();
             mainFrame.getPanel().clearDebuggerColors();
             Main.startWork(AppStrings.translate("work.debugging") + "...", null);
             cmd.stepOut();
         } catch (IOException ex) {
-            Main.getDebugHandler().disconnect();
+            Main.getCurrentDebugSession().disconnect();
             //ignore
         }
 
@@ -1813,12 +1813,12 @@ public abstract class MainFrameMenu implements MenuBuilder {
 
     public boolean continueActionPerformed(ActionEvent evt) {
         try {
-            DebuggerCommands cmd = Main.getDebugHandler().getCommands();
+            DebuggerCommands cmd = Main.getCurrentDebugSession().getCommands();
             mainFrame.getPanel().clearDebuggerColors();
             Main.startWork(AppStrings.translate("work.debugging") + "...", null);
             cmd.sendContinue();
         } catch (IOException ex) {
-            Main.getDebugHandler().disconnect();
+            Main.getCurrentDebugSession().disconnect();
             //ignore
         }
 
diff --git a/src/com/jpexs/decompiler/flash/gui/MainPanel.java b/src/com/jpexs/decompiler/flash/gui/MainPanel.java
index 198580364..7c6f78b13 100644
--- a/src/com/jpexs/decompiler/flash/gui/MainPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/MainPanel.java
@@ -451,6 +451,8 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
     private boolean loadingScrollPosEnabled = true;
     
     private static final DataFlavor TREE_FILE_FLAVOR = new DataFlavor(TreeFileFlavor.class, "TreeFile");
+    
+    private boolean editingStatusSet = false;
 
     public synchronized void setLoadingScrollPosEnabled(boolean loadingScrollPosEnabled) {
         this.loadingScrollPosEnabled = loadingScrollPosEnabled;
@@ -972,11 +974,15 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
     }
 
     public void setEditingStatus() {
+        editingStatusSet = true;
         statusPanel.setStatus(translate(Configuration.autoSaveTagModifications.get() ? "status.editing.autosave" : "status.editing"));
     }
 
     public void clearEditingStatus() {
-        statusPanel.setStatus("");
+        if (editingStatusSet) {
+            statusPanel.setStatus("");
+            editingStatusSet = false;
+        }
     }
 
     public void setWorkStatus(String s, CancellableWorker worker) {
@@ -1116,7 +1122,7 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
         debugStackPanel = new DebugStackPanel();
         Main.getDebugHandler().addBreakListener(new DebuggerHandler.BreakListener() {
             @Override
-            public void breakAt(String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
+            public void breakAt(DebuggerSession session, String scriptName, int line, int classIndex, int traitIndex, int methodIndex) {
                 View.execInEventDispatchLater(new Runnable() {
                     @Override
                     public void run() {
@@ -1126,23 +1132,25 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
             }
 
             @Override
-            public void doContinue() {
+            public void doContinue(DebuggerSession session) {
                 View.execInEventDispatchLater(new Runnable() {
                     @Override
                     public void run() {
-                        showDetail(DETAILCARDEMPTYPANEL);
+                        if (Main.getDebugHandler().getNumberOfPausedSessions() == 0) {
+                            showDetail(DETAILCARDEMPTYPANEL);
+                        }
                     }
                 });
             }
         });
         Main.getDebugHandler().addConnectionListener(new DebuggerHandler.ConnectionListener() {
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
 
             }
 
             @Override
-            public void disconnected() {
+            public void disconnected(DebuggerSession session) {
                 View.execInEventDispatchLater(new Runnable() {
                     @Override
                     public void run() {
@@ -1628,6 +1636,7 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
 
     private void updateUi(final Openable openable) {
         View.checkAccess();
+        Main.updateSession();
         SWF swf = null;
         if (openable instanceof SWF) {
             swf = (SWF) openable;
@@ -1646,7 +1655,7 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
                 if (!abcFound) {
                     getABCPanel().setAbc(abcList.get(0).getABC());
                 }
-            }
+            }            
         }
         mainMenu.updateComponents(openable);
 
@@ -5766,7 +5775,8 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
 
     private void valueChanged(Object source, TreePath selectedPath) {
         TreeItem treeItem = selectedPath == null ? null : (TreeItem) selectedPath.getLastPathComponent();
-
+        
+        Main.updateSession();
         if (treeItem == null) {
             updateUi(null);
             reload(false);
@@ -6360,7 +6370,7 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
         if (openable instanceof SWF) {
             SwfSpecificCustomConfiguration swfCustomConf = Configuration.getOrCreateSwfSpecificCustomConfiguration(openable.getShortPathTitle());
             SWF swf = (SWF) openable;
-            Map<String, Set<Integer>> breakpoints = Main.getDebugHandler().getAllBreakPoints(swf, false);
+            Map<String, Set<Integer>> breakpoints = Main.getDebugHandler().getAllSessionsBreakPoints(swf);
             List<String> breakpointList = new ArrayList<>();
             for (String scriptName : breakpoints.keySet()) {
                 for (int line : breakpoints.get(scriptName)) {
@@ -7053,4 +7063,8 @@ public final class MainPanel extends JPanel implements TreeSelectionListener, Se
     public EasyPanel getEasyPanel() {
         return easyPanel;
     }
+    
+    public void showDebugStackFrame() {
+        showDetail(DETAILCARDDEBUGSTACKFRAME);
+    }
 }
diff --git a/src/com/jpexs/decompiler/flash/gui/abc/ABCPanel.java b/src/com/jpexs/decompiler/flash/gui/abc/ABCPanel.java
index 92e99c912..ee0211495 100644
--- a/src/com/jpexs/decompiler/flash/gui/abc/ABCPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/abc/ABCPanel.java
@@ -56,6 +56,7 @@ import com.jpexs.decompiler.flash.gui.AppDialog;
 import com.jpexs.decompiler.flash.gui.AppStrings;
 import com.jpexs.decompiler.flash.gui.DebugPanel;
 import com.jpexs.decompiler.flash.gui.DebuggerHandler;
+import com.jpexs.decompiler.flash.gui.DebuggerSession;
 import com.jpexs.decompiler.flash.gui.FasterScrollPane;
 import com.jpexs.decompiler.flash.gui.HeaderLabel;
 import com.jpexs.decompiler.flash.gui.Main;
@@ -388,9 +389,9 @@ public class ABCPanel extends JPanel implements ItemListener, SearchListener<Scr
             boolean isAS3 = (Main.getMainFrame().getPanel().getCurrentSwf().isAS3());
 
             if (parentObjectId == 0 && objectId != 0L && isAS3) {
-                igv = Main.getDebugHandler().getVariable(objectId, "", true, useGetter);
+                igv = Main.getCurrentDebugSession().getVariable(objectId, "", true, useGetter);
             } else {
-                igv = Main.getDebugHandler().getVariable(parentObjectId, var.name, true, useGetter);
+                igv = Main.getCurrentDebugSession().getVariable(parentObjectId, var.name, true, useGetter);
             }
 
             //current var is getter function - set it to value really got
@@ -782,7 +783,7 @@ public class ABCPanel extends JPanel implements ItemListener, SearchListener<Scr
                 default:
                     return;
             }
-            Main.getDebugHandler().setVariable(((VariableNode) node).parentObjectId, ((VariableNode) node).var.name, valType, symb.value);
+            Main.getCurrentDebugSession().setVariable(((VariableNode) node).parentObjectId, ((VariableNode) node).var.name, valType, symb.value);
             //((VariableNode) node).refresh();
             Object[] path = new Object[((VariableNode) node).path.size()];
             for (int i = 0; i < path.length; i++) {
@@ -1422,13 +1423,15 @@ public class ABCPanel extends JPanel implements ItemListener, SearchListener<Scr
 
         Main.getDebugHandler().addConnectionListener(new DebuggerHandler.ConnectionListener() {
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
                 decButtonsPan.setVisible(false);
             }
 
             @Override
-            public void disconnected() {
-                decButtonsPan.setVisible(true);
+            public void disconnected(DebuggerSession session) {
+                if (!Main.getDebugHandler().isAnySessionConnected()) {
+                    decButtonsPan.setVisible(true);
+                }
             }
         });
 
diff --git a/src/com/jpexs/decompiler/flash/gui/abc/DetailPanel.java b/src/com/jpexs/decompiler/flash/gui/abc/DetailPanel.java
index 2d764f1ac..71e5dc67f 100644
--- a/src/com/jpexs/decompiler/flash/gui/abc/DetailPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/abc/DetailPanel.java
@@ -22,6 +22,7 @@ import com.jpexs.decompiler.flash.abc.types.traits.Trait;
 import com.jpexs.decompiler.flash.configuration.Configuration;
 import com.jpexs.decompiler.flash.gui.AppStrings;
 import com.jpexs.decompiler.flash.gui.DebuggerHandler;
+import com.jpexs.decompiler.flash.gui.DebuggerSession;
 import com.jpexs.decompiler.flash.gui.HeaderLabel;
 import com.jpexs.decompiler.flash.gui.Main;
 import com.jpexs.decompiler.flash.gui.MainPanel;
@@ -146,7 +147,7 @@ public class DetailPanel extends JPanel implements TagEditorPanel {
 
         conListener = new DebuggerHandler.ConnectionListener() {
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
                 synchronized (DetailPanel.this) {
                     debugRunning = true;
                     if (buttonsPanel != null) {
@@ -156,7 +157,10 @@ public class DetailPanel extends JPanel implements TagEditorPanel {
             }
 
             @Override
-            public void disconnected() {
+            public void disconnected(DebuggerSession session) {
+                if (Main.getDebugHandler().isAnySessionConnected()) {
+                    return;
+                }
                 synchronized (DetailPanel.this) {
                     debugRunning = false;
 
diff --git a/src/com/jpexs/decompiler/flash/gui/action/ActionPanel.java b/src/com/jpexs/decompiler/flash/gui/action/ActionPanel.java
index 65e84b9c5..fb2c472ce 100644
--- a/src/com/jpexs/decompiler/flash/gui/action/ActionPanel.java
+++ b/src/com/jpexs/decompiler/flash/gui/action/ActionPanel.java
@@ -43,6 +43,7 @@ import com.jpexs.decompiler.flash.exporters.modes.ScriptExportMode;
 import com.jpexs.decompiler.flash.gui.AppStrings;
 import com.jpexs.decompiler.flash.gui.DebugPanel;
 import com.jpexs.decompiler.flash.gui.DebuggerHandler;
+import com.jpexs.decompiler.flash.gui.DebuggerSession;
 import com.jpexs.decompiler.flash.gui.DocsPanel;
 import com.jpexs.decompiler.flash.gui.FasterScrollPane;
 import com.jpexs.decompiler.flash.gui.GraphDialog;
@@ -1065,12 +1066,15 @@ public class ActionPanel extends JPanel implements SearchListener<ScriptSearchRe
         //decPanel.add(searchPanel, BorderLayout.NORTH);
         Main.getDebugHandler().addConnectionListener(new DebuggerHandler.ConnectionListener() {
             @Override
-            public void connected() {
+            public void connected(DebuggerSession session) {
                 decButtonsPan.setVisible(false);
             }
 
             @Override
-            public void disconnected() {
+            public void disconnected(DebuggerSession session) {
+                if (Main.getDebugHandler().isAnySessionConnected()) {
+                    return;
+                }
                 decButtonsPan.setVisible(true);
             }
         });
diff --git a/src/com/jpexs/decompiler/flash/gui/editor/DebuggableEditorPane.java b/src/com/jpexs/decompiler/flash/gui/editor/DebuggableEditorPane.java
index a75a121af..43b992628 100644
--- a/src/com/jpexs/decompiler/flash/gui/editor/DebuggableEditorPane.java
+++ b/src/com/jpexs/decompiler/flash/gui/editor/DebuggableEditorPane.java
@@ -126,7 +126,7 @@ public class DebuggableEditorPane extends LineMarkedEditorPane implements BreakP
             return;
         }
 
-        Set<Integer> bkptLines = Main.getScriptBreakPoints(breakPointScriptName, false);
+        Set<Integer> bkptLines = Main.getScriptBreakPoints(breakPointScriptName);
 
         for (int line : bkptLines) {
             if (Main.isBreakPointValid(breakPointScriptName, line)) {