diff --git a/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/OnlineTraceOutput.java b/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/OnlineTraceOutput.java
index 0dee3a8..60fcff7 100644
--- a/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/OnlineTraceOutput.java
+++ b/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/OnlineTraceOutput.java
@@ -1,100 +1,195 @@
 package org.ntlab.traceCollector.tracer;
 
-import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Stack;
 
-import org.ntlab.traceCollector.tracer.trace.ArrayUpdate;
-import org.ntlab.traceCollector.tracer.trace.ClassInfo;
-import org.ntlab.traceCollector.tracer.trace.FieldUpdate;
-import org.ntlab.traceCollector.tracer.trace.MethodExecution;
-import org.ntlab.traceCollector.tracer.trace.MethodInvocation;
+import org.ntlab.traceCollector.tracer.trace.ObjectReference;
 import org.ntlab.traceCollector.tracer.trace.ThreadInstance;
 import org.ntlab.traceCollector.tracer.trace.TraceJSON;
-import org.ntlab.traceCollector.tracer.trace.TracePoint;
 
 public class OnlineTraceOutput {
+	private static ThreadInstance thread = null;
 
-	public static void onlineTraceClassDefinition(String className,
-			String classPath, String loaderPath) {
-		TraceJSON.onlineTraceClassDefinition(className, classPath, loaderPath);
+	public static void onlineTraceClassDefinition(String className, String classPath, String loaderPath) {
+		// classPath��loaderPath�ɂ‚��Ă͐擪�� / ����菜���ċL�^����
+		TraceJSON.initializeClass(className, classPath.substring(1), loaderPath.substring(1));
 	}
 
-	public static void onlineTracePreCallMethod(String signature,
-			String threadId, String lineNum) {
-		TraceJSON.onlineTracePreCallMethod(signature, threadId, lineNum);
-	}
-	
-	public static void onlineTraceMethodEntry(String signature,
-			String thisClassName, String thisObjectId, String threadId,
-			long timeStamp, String argList) {
-		TraceJSON.onlineTraceMethodEntry(signature, thisClassName,
-				thisObjectId, threadId, timeStamp, argList);
+	public static void onlineTracePreCallMethod(String signature, String threadId, String lineNum) {
+		TraceJSON.getThreadInstance(threadId).preCallMethod(signature, Integer.parseInt(lineNum));
 	}
 
-	public static void onlineTraceConstructorEntry(String signature,
-			String thisClassName, String thisObjectId, String threadId,
-			long timeStamp, String argList) {
-		TraceJSON.onlineTraceConstructorEntry(signature, thisClassName,
-				thisObjectId, threadId, timeStamp, argList);
+	public static void onlineTraceMethodEntry(String signature, String thisClassName, String thisObjectId,
+			String threadId, long timeStamp, String argList) {
+		boolean isConstractor = false;
+		boolean isStatic = false;
+		if (signature.contains("static ")) {
+			isStatic = true;
+		}
+		thread = TraceJSON.getThreadInstance(threadId);
+		Stack<String> stack;
+		if (thread == null) {
+			thread = new ThreadInstance(threadId);
+			TraceJSON.getThreads().put(threadId, thread);
+			stack = new Stack<String>();
+			TraceJSON.getStacks().put(threadId, stack);
+		} else {
+			stack = TraceJSON.getStacks().get(threadId);
+		}
+		stack.push(signature);
+		// ���\�b�h�Ăяo���̐ݒ�
+		thread.callMethod(signature, null, thisClassName, thisObjectId, isConstractor, isStatic, timeStamp);
+		// �����̐ݒ�
+		ArrayList<ObjectReference> arguments = new ArrayList<>();
+		String[] args = argList.split(",");
+		for (int i = 0; i < args.length - 1; i += 2) {
+			arguments.add(new ObjectReference(args[i + 1], args[i]));
+		}
+		thread.setArgments(arguments);
 	}
 
-	public static void onlineTraceMethodExit(String shortSignature,
-			String thisClassName, String thisObjectId, String returnClassName,
-			String returnObjectId, String threadId, long timeStamp) {
-		TraceJSON.onlineTraceMethodExit(shortSignature, thisClassName,
-				thisObjectId, returnClassName, returnObjectId, threadId,
-				timeStamp);
+	public static void onlineTraceConstructorEntry(String signature, String thisClassName, String thisObjectId,
+			String threadId, long timeStamp, String argList) {
+		boolean isConstractor = true;
+		boolean isStatic = false;
+		thread = TraceJSON.getThreadInstance(threadId);
+		Stack<String> stack;
+		if (thread == null) {
+			thread = new ThreadInstance(threadId);
+			TraceJSON.getThreads().put(threadId, thread);
+			stack = new Stack<String>();
+			TraceJSON.getStacks().put(threadId, stack);
+		} else {
+			stack = TraceJSON.getStacks().get(threadId);
+		}
+		stack.push(signature);
+		// ���\�b�h�Ăяo���̐ݒ�
+		thread.callMethod(signature, null, thisClassName, thisObjectId, isConstractor, isStatic, timeStamp);
+		// �����̐ݒ�
+		ArrayList<ObjectReference> arguments = new ArrayList<>();
+		String[] args = argList.split(",");
+		for (int i = 0; i < args.length - 1; i += 2) {
+			arguments.add(new ObjectReference(args[i + 1], args[i]));
+		}
+		thread.setArgments(arguments);
 	}
 
-	public static void onlineTraceConstructorExit(String shortSignature,
-			String returnClassName, String returnObjectId, String threadId,
-			long timeStamp) {
-		TraceJSON.onlineTraceConstructorExit(shortSignature, returnClassName,
-				returnObjectId, threadId, timeStamp);
+	public static void onlineTraceMethodExit(String shortSignature, String thisClassName, String thisObjectId,
+			String returnClassName, String returnObjectId, String threadId, long timeStamp) {
+		Stack<String> stack = TraceJSON.getStacks().get(threadId);
+		if (!stack.isEmpty()) {
+			String line2 = stack.peek();
+			if (line2.endsWith(shortSignature)) {
+				stack.pop();
+			} else {
+				do {
+					stack.pop();
+					thread.terminateMethod();
+					if (stack.isEmpty()) break;
+					line2 = stack.peek();
+				} while (!stack.isEmpty() && !line2.endsWith(shortSignature));
+				if (!stack.isEmpty()) stack.pop();
+			}
+			thread = TraceJSON.getThreadInstance(threadId);
+			ObjectReference returnVal = new ObjectReference(returnObjectId, returnClassName);
+			boolean isCollectionType = false;
+			if (thisClassName.contains("java.util.List") || thisClassName.contains("java.util.Vector")
+					|| thisClassName.contains("java.util.Iterator") || thisClassName.contains("java.util.ListIterator")
+					|| thisClassName.contains("java.util.ArrayList") || thisClassName.contains("java.util.Stack")
+					|| thisClassName.contains("java.util.Hash") || thisClassName.contains("java.util.Map")
+					|| thisClassName.contains("java.util.Set") || thisClassName.contains("java.util.Linked")
+					|| thisClassName.contains("java.lang.Thread")) {
+				isCollectionType = true;
+			}
+			// ���\�b�h����̕��A�̐ݒ�
+			thread.returnMethod(returnVal, thisObjectId, isCollectionType, timeStamp);
+		}
 	}
 
-	public static void onlineTraceFieldGet(String fieldName,
-			String thisClassName, String thisObjectId,
-			String containerClassName, String containerObjectId,
-			String valueClassName, String valueObjectId, String threadId,
-			String lineNum, long timeStamp) {
-		TraceJSON.onlineTraceFieldGet(fieldName, thisClassName, thisObjectId,
-				containerClassName, containerObjectId, valueClassName,
-				valueObjectId, threadId, lineNum, timeStamp);
+	public static void onlineTraceConstructorExit(String shortSignature, String returnClassName, String returnObjectId,
+			String threadId, long timeStamp) {
+		String thisClassName = returnClassName;
+		String thisObjectId = returnObjectId;
+		Stack<String> stack = TraceJSON.getStacks().get(threadId);
+		if (!stack.isEmpty()) {
+			String line2 = stack.peek();
+			if (line2.endsWith(shortSignature)) {
+				stack.pop();
+			} else {
+				do {
+					stack.pop();
+					thread.terminateMethod();
+					if (stack.isEmpty()) break; // ���̈ꕶ�����ɒlj�(MethodExit�̕������l)
+					line2 = stack.peek();
+				} while (!stack.isEmpty() && !line2.endsWith(shortSignature));
+				if (!stack.isEmpty()) stack.pop();
+			}
+			thread = TraceJSON.getThreadInstance(threadId);
+			ObjectReference returnVal = new ObjectReference(returnObjectId, returnClassName);
+			boolean isCollectionType = false;
+			if (thisClassName.contains("java.util.List") || thisClassName.contains("java.util.Vector")
+					|| thisClassName.contains("java.util.Iterator") || thisClassName.contains("java.util.ListIterator")
+					|| thisClassName.contains("java.util.ArrayList") || thisClassName.contains("java.util.Stack")
+					|| thisClassName.contains("java.util.Hash") || thisClassName.contains("java.util.Map")
+					|| thisClassName.contains("java.util.Set") || thisClassName.contains("java.util.Linked")
+					|| thisClassName.contains("java.lang.Thread")) {
+				isCollectionType = true;
+			}
+			// ���\�b�h����̕��A�̐ݒ�
+			thread.returnMethod(returnVal, thisObjectId, isCollectionType, timeStamp);
+		}
 	}
 
-	public static void onlineTraceFieldSet(String fieldName,
-			String containerClassName, String containerObjectId,
-			String valueClassName, String valueObjectId, String threadId,
-			String lineNum, long timeStamp) {
-		TraceJSON.onlineTraceFieldSet(fieldName, containerClassName,
-				containerObjectId, valueClassName, valueObjectId, threadId,
-				lineNum, timeStamp);
-	}
-
-	public static void onlineTraceArrayCreate(String arrayClassName,
-			String arrayObjectId, String dimension, String threadId,
-			String lineNum, long timeStamp) {
-		TraceJSON.onlineTraceArrayCreate(arrayClassName, arrayObjectId,
-				dimension, threadId, lineNum, timeStamp);
-	}
-
-	public static void onlineTraceArraySet(String arrayClassName,
-			String arrayObjectId, int index, String valueClassName,
-			String valueObjectId, String threadId, long timeStamp) {
-		TraceJSON.onlineTraceArraySet(arrayClassName, arrayObjectId, index,
-				valueClassName, valueObjectId, threadId, timeStamp);
-	}
-
-	public static void onlineTraceArrayGet(String arrayClassName,
-			String arrayObjectId, int index, String valueClassName,
-			String valueObjectId, String threadId, long timeStamp) {
-		TraceJSON.onlineTraceArrayGet(arrayClassName, arrayObjectId, index,
-				valueClassName, valueObjectId, threadId, timeStamp);
-	}
-
-	public static void onlineTraceBlockEntry(String blockId, String incomings,
+	public static void onlineTraceFieldGet(String fieldName, String thisClassName, String thisObjectId,
+			String containerClassName, String containerObjectId, String valueClassName, String valueObjectId,
 			String threadId, String lineNum, long timeStamp) {
-		TraceJSON.onlineTraceBlockEntry(blockId, incomings, threadId, lineNum,
-				timeStamp);
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.fieldAccess(fieldName, valueClassName, valueObjectId, containerClassName, containerObjectId,
+					thisClassName, thisObjectId, Integer.parseInt(lineNum), timeStamp);
+		}
 	}
-}
+
+	public static void onlineTraceFieldSet(String fieldName, String containerClassName, String containerObjectId,
+			String valueClassName, String valueObjectId, String threadId, String lineNum, long timeStamp) {
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.fieldUpdate(fieldName, valueClassName, valueObjectId, containerClassName, containerObjectId,
+					Integer.parseInt(lineNum), timeStamp);
+		}
+	}
+
+	public static void onlineTraceArrayCreate(String arrayClassName, String arrayObjectId, String dimension,
+			String threadId, String lineNum, long timeStamp) {
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.arrayCreate(arrayClassName, arrayObjectId, Integer.parseInt(dimension), Integer.parseInt(lineNum),
+					timeStamp);
+		}
+	}
+
+	public static void onlineTraceArraySet(String arrayClassName, String arrayObjectId, int index,
+			String valueClassName, String valueObjectId, String threadId, long timeStamp) {
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.arraySet(arrayClassName, arrayObjectId, index, valueClassName, valueObjectId, 0, timeStamp);
+		}
+	}
+
+	public static void onlineTraceArrayGet(String arrayClassName, String arrayObjectId, int index,
+			String valueClassName, String valueObjectId, String threadId, long timeStamp) {
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.arrayGet(arrayClassName, arrayObjectId, index, valueClassName, valueObjectId, 0, timeStamp);
+		}
+	}
+
+	public static void onlineTraceBlockEntry(String blockId, String incomings, String threadId, String lineNum,
+			long timeStamp) {
+		thread = TraceJSON.getThreadInstance(threadId);
+		if (thread != null) {
+			thread.blockEnter(Integer.parseInt(blockId), Integer.parseInt(incomings), Integer.parseInt(lineNum),
+					timeStamp);
+		}
+	}
+}
\ No newline at end of file
diff --git a/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/trace/TraceJSON.java b/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/trace/TraceJSON.java
index 2409545..3f1f6ab 100644
--- a/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/trace/TraceJSON.java
+++ b/org.ntlab.traceCollector/src/org/ntlab/traceCollector/tracer/trace/TraceJSON.java
@@ -13,16 +13,9 @@
 import java.util.Map;
 import java.util.Stack;
 
-import org.ntlab.traceCollector.tracer.OnlineTraceOutput;
-
-//import com.sun.jdi.ObjectReference;
-//import com.sun.jdi.Value;
-
 public class TraceJSON extends Trace {
-//	private static TraceJSON theTrace = null;
 	private HashMap<String, ClassInfo> classes = new HashMap<>();
 	private HashMap<String, Stack<String>> stacks = new HashMap<String, Stack<String>>();
-	private ThreadInstance thread = null;
 	
 	private TraceJSON() {
 		
@@ -425,25 +418,11 @@
 		}
 		return argumentsData;
 	}
-	
-//	public void initializeClass(String name, String path, String loaderPath) {
-//		classes.put(name, new ClassInfo(name, path, loaderPath));
-//	}
-	
+
 	public static void initializeClass(String name, String path, String loaderPath) {
 		getInstance().classes.put(name, new ClassInfo(name, path, loaderPath));
-
-		// �m�F�p
-		System.out.println("name = " + name);
-		System.out.println("path = " + path);
-		System.out.println("loaderPath = " + loaderPath);
-		System.out.println();
 	}
-	
-//	public ClassInfo getClassInfo(String className) {
-//		return classes.get(className);
-//	}
-	
+
 	public static ClassInfo getClassInfo(String className) {
 		return getInstance().classes.get(className);
 	}
@@ -668,195 +647,16 @@
 		return getInstance().threads;
 	}
 	
-	public static synchronized void onlineTraceClassDefinition(String className, String classPath, String loaderPath) {
-		// classPath��loaderPath�ɂ‚��Ă͐擪�� / ����菜���ċL�^���� (readJSON���ł̏����Ɠ����ɂȂ�)
-		initializeClass(className, classPath.substring(1), loaderPath.substring(1));
+	public static HashMap<String, Stack<String>> getStacks() {
+		return getInstance().stacks;
 	}
 	
-	public static synchronized void onlineTracePreCallMethod(String signature, String threadId, String lineNum) {
-		getInstance().thread = getInstance().threads.get(threadId);
-		getInstance().thread.preCallMethod(signature, Integer.parseInt(lineNum));
-	}
-	
-	public static synchronized void onlineTraceMethodEntry(String signature, String thisClassName, String thisObjectId, 
-			String threadId, long timeStamp, String argList) {
-		boolean isConstractor = false;
-		boolean isStatic = false;
-		if (signature.contains("static ")) {
-			isStatic = true;
-		}
-		getInstance().thread = getInstance().threads.get(threadId);		
-		Stack<String> stack;
-		if (getInstance().thread  == null) {
-			getInstance().thread = new ThreadInstance(threadId);
-			getInstance().threads.put(threadId, getInstance().thread);
-			stack = new Stack<String>();
-			getInstance().stacks.put(threadId, stack);
-		} else {
-			stack = getInstance().stacks.get(threadId);
-		}
-		stack.push(signature);
-		// ���\�b�h�Ăяo���̐ݒ�
-		getInstance().thread.callMethod(signature, null, thisClassName, thisObjectId, isConstractor, isStatic, timeStamp);
-		// �����̐ݒ�
-		ArrayList<ObjectReference> arguments = new ArrayList<>();
-		String[] args = argList.split(",");
-		for (int i = 0; i < args.length - 1; i += 2) {
-			arguments.add(new ObjectReference(args[i+1], args[i]));
-		}
-		getInstance().thread.setArgments(arguments);
-	}
-	
-	public static synchronized void onlineTraceConstructorEntry(String signature, String thisClassName, String thisObjectId, 
-			String threadId, long timeStamp, String argList) {
-		boolean isConstractor = true;
-		boolean isStatic = false;
-		getInstance().thread = getInstance().threads.get(threadId);
-		Stack<String> stack;
-		if (getInstance().thread == null) {
-			getInstance().thread = new ThreadInstance(threadId);
-			getInstance().threads.put(threadId, getInstance().thread);
-			stack = new Stack<String>();
-			getInstance().stacks.put(threadId, stack);
-		} else {
-			stack = getInstance().stacks.get(threadId);
-		}
-		stack.push(signature);
-		// ���\�b�h�Ăяo���̐ݒ�
-		getInstance().thread.callMethod(signature, null, thisClassName, thisObjectId, isConstractor, isStatic, timeStamp);
-		// �����̐ݒ�
-		ArrayList<ObjectReference> arguments = new ArrayList<>();
-		String[] args = argList.split(",");
-		for (int i = 0; i < args.length - 1; i += 2) {
-			arguments.add(new ObjectReference(args[i+1], args[i]));
-		}
-		getInstance().thread.setArgments(arguments);
-	}
-	
-	public static synchronized void onlineTraceMethodExit(String shortSignature, String thisClassName, String thisObjectId, 
-			String returnClassName, String returnObjectId, String threadId, long timeStamp) {
-		Stack<String> stack = getInstance().stacks.get(threadId);
-		if (!stack.isEmpty()) {
-			String line2 = stack.peek();
-			if (line2.endsWith(shortSignature)) {
-				stack.pop();
-			} else {
-				do {
-					stack.pop();
-					getInstance().thread.terminateMethod();
-					if (stack.isEmpty()) break;
-					line2 = stack.peek();
-				} while (!stack.isEmpty() && !line2.endsWith(shortSignature));
-				if (!stack.isEmpty()) stack.pop();
-			}
-			getInstance().thread = getInstance().threads.get(threadId);
-			ObjectReference returnVal = new ObjectReference(returnObjectId, returnClassName);					
-			boolean isCollectionType = false;
-			if(thisClassName.contains("java.util.List")
-					|| thisClassName.contains("java.util.Vector")
-					|| thisClassName.contains("java.util.Iterator")
-					|| thisClassName.contains("java.util.ListIterator")
-					|| thisClassName.contains("java.util.ArrayList")
-					|| thisClassName.contains("java.util.Stack")
-					|| thisClassName.contains("java.util.Hash")
-					|| thisClassName.contains("java.util.Map")
-					|| thisClassName.contains("java.util.Set")
-					|| thisClassName.contains("java.util.Linked")
-					|| thisClassName.contains("java.lang.Thread")) {
-				isCollectionType = true;
-			}
-			// ���\�b�h����̕��A�̐ݒ�
-			getInstance().thread.returnMethod(returnVal, thisObjectId, isCollectionType, timeStamp);
-		}
-	}
-	
-	public static synchronized void onlineTraceConstructorExit(String shortSignature, String returnClassName, String returnObjectId, 
-			String threadId, long timeStamp) {
-		String thisClassName = returnClassName;
-		String thisObjectId = returnObjectId;
-		Stack<String> stack = getInstance().stacks.get(threadId);
-		if (!stack.isEmpty()) {
-			String line2 = stack.peek();
-			if (line2.endsWith(shortSignature)) {
-				stack.pop();
-			} else {
-				do {
-					stack.pop();
-					getInstance().thread.terminateMethod();
-					if (stack.isEmpty()) break; // ���̈ꕶ�����ɒlj�(MethodExit�̕������l)
-					line2 = stack.peek();
-				} while (!stack.isEmpty() && !line2.endsWith(shortSignature));
-				if (!stack.isEmpty()) stack.pop();
-			}
-			getInstance().thread = getInstance().threads.get(threadId);
-			ObjectReference returnVal = new ObjectReference(returnObjectId, returnClassName);					
-			boolean isCollectionType = false;
-			if(thisClassName.contains("java.util.List")
-					|| thisClassName.contains("java.util.Vector")
-					|| thisClassName.contains("java.util.Iterator")
-					|| thisClassName.contains("java.util.ListIterator")
-					|| thisClassName.contains("java.util.ArrayList")
-					|| thisClassName.contains("java.util.Stack")
-					|| thisClassName.contains("java.util.Hash")
-					|| thisClassName.contains("java.util.Map")
-					|| thisClassName.contains("java.util.Set")
-					|| thisClassName.contains("java.util.Linked")
-					|| thisClassName.contains("java.lang.Thread")) {
-				isCollectionType = true;
-			}
-			// ���\�b�h����̕��A�̐ݒ�
-			getInstance().thread.returnMethod(returnVal, thisObjectId, isCollectionType, timeStamp);
-		}
-	}
-	
-	public static synchronized void onlineTraceFieldGet(String fieldName, String thisClassName, String thisObjectId, 
-			String containerClassName, String containerObjectId, String valueClassName, String valueObjectId,
-			String threadId, String lineNum, long timeStamp) {
-		getInstance().thread = getInstance().threads.get(threadId);
-		// �t�B�[���h�A�N�Z�X�̐ݒ�
-		if (getInstance().thread != null) getInstance().thread.fieldAccess(fieldName, valueClassName, valueObjectId, containerClassName, containerObjectId, thisClassName, thisObjectId, Integer.parseInt(lineNum), timeStamp);
-	}
-	
-	public static synchronized void onlineTraceFieldSet(String fieldName, String containerClassName, String containerObjectId, 
-			String valueClassName, String valueObjectId, String threadId, String lineNum, long timeStamp) {
-		getInstance().thread = getInstance().threads.get(threadId);
-		// �t�B�[���h�X�V�̐ݒ�
-		if (getInstance().thread != null) getInstance().thread.fieldUpdate(fieldName, valueClassName, valueObjectId, containerClassName, containerObjectId, Integer.parseInt(lineNum), timeStamp);
-	}
-	
-	public static synchronized void onlineTraceArrayCreate(String arrayClassName, String arrayObjectId, String dimension, 
-			String threadId, String lineNum, long timeStamp) {
-		getInstance().thread = getInstance().threads.get(threadId);
-		if (getInstance().thread != null) getInstance().thread.arrayCreate(arrayClassName, arrayObjectId, Integer.parseInt(dimension), Integer.parseInt(lineNum), timeStamp);
-	}
-			
-	public static synchronized void onlineTraceArraySet(String arrayClassName, String arrayObjectId, int index, 
-			String valueClassName, String valueObjectId, String threadId, long timeStamp) {
-		// �z��v�f�ւ̑��
-		getInstance().thread = getInstance().threads.get(threadId);
-		if (getInstance().thread != null) getInstance().thread.arraySet(arrayClassName, arrayObjectId, index, valueClassName, valueObjectId, 0, timeStamp);
-	}
-	
-	public static synchronized void onlineTraceArrayGet(String arrayClassName, String arrayObjectId, int index, 
-			String valueClassName, String valueObjectId, String threadId, long timeStamp) {
-		// �z��v�f�̎Q��
-		getInstance().thread = getInstance().threads.get(threadId);
-		if (getInstance().thread != null) getInstance().thread.arrayGet(arrayClassName, arrayObjectId, index, valueClassName, valueObjectId, 0, timeStamp);
-	}
-
-	public static synchronized void onlineTraceBlockEntry(String blockId, String incomings, 
-			String threadId, String lineNum, long timeStamp) {
-		// �u���b�N�̊J�n
-		getInstance().thread = getInstance().threads.get(threadId);
-		if (getInstance().thread != null) getInstance().thread.blockEnter(Integer.parseInt(blockId), Integer.parseInt(incomings), Integer.parseInt(lineNum), timeStamp);
-	}
-
 	public static ThreadInstance getThreadInstance(String threadId) {
 		return getInstance().threads.get(threadId);
 	}
 	
 	/**
-	 * �w�肵���X���b�h��Ō��ݎ��s���̃��\�b�h���s���擾����(�I�����C����͗p)
+	 * �w�肵���X���b�h��Ō��ݎ��s���̃��\�b�h���s���擾����
 	 * @param thread �ΏۃX���b�h
 	 * @return thread ��Ō��ݎ��s���̃��\�b�h���s
 	 */
@@ -866,7 +666,7 @@
 	}
 	
 	/**
-	 * �w�肵���X���b�h��Ō��ݎ��s���̃g���[�X�|�C���g���擾����(�I�����C����͗p)
+	 * �w�肵���X���b�h��Ō��ݎ��s���̃g���[�X�|�C���g���擾����
 	 * @param thread �ΏۃX���b�h
 	 * @return thread ��Ō��ݎ��s���̎��s���̃g���[�X�|�C���g
 	 */
@@ -896,15 +696,6 @@
 		}
 		return null;
 	}
-	
-//	private static TracePoint getRecentlyFieldUpdate(TracePoint tp) {
-//		Statement statement = tp.getStatement();
-//		if (statement instanceof FieldAccess) {
-//			FieldAccess fa = (FieldAccess)statement;
-//			return getFieldUpdateTracePoint(fa.getContainerObjId(), fa.getFieldName(), tp);
-//		}
-//		return null;
-//	}
 
 	/**
 	 * �����Ŏw�肵���R���e�i�̎��“���̃t�B�[���h���Ō�ɍX�V���ꂽstatement���t�����ɒT�����āA<br>
@@ -959,15 +750,6 @@
 		}
 		return null;		
 	}
-	
-//	private static TracePoint getRecentlyArrayUpdate(TracePoint tp) {
-//		Statement statement = tp.getStatement();
-//		if (statement instanceof ArrayAccess) {
-//			ArrayAccess aa = (ArrayAccess)statement;
-//			return getArrayUpdateTracePoint(aa.getArrayObjectId(), aa.getIndex(), tp);
-//		}
-//		return null;
-//	}
 
 	/**
 	 * �����Ŏw�肵���z��ŁA���Žw�肵���C���f�b�N�X���Ō�ɍX�V���ꂽstatement���t�����ɒT�����āA<br>
@@ -1000,193 +782,4 @@
 		}
 		return null;
 	}
-	
-//	public static ArrayList<Alias> findAllStartAlias(MethodExecution me) {
-//		ArrayList<Alias> startAliasList = new ArrayList<>();
-//		List<Statement> statements = me.getStatements();
-//		String[] primitives = {"byte", "short", "int", "long", "float", "double", "char", "boolean"};
-//		List<String> primitiveList = Arrays.asList(primitives);
-//		for (int i = 0; i < statements.size(); i++) {
-//			TracePoint tp = me.getTracePoint(i);
-//			Statement statement = statements.get(i);
-//			if (statement instanceof FieldAccess) {
-//				FieldAccess fa = (FieldAccess)statement;
-//				String objId = fa.getContainerObjId();
-//				if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getContainerClassName()))) {
-//					startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER));
-//				}
-//				objId = fa.getValueObjId();
-//				if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fa.getValueClassName()))) {
-//					startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD));
-//				}
-//			} else if (statement instanceof FieldUpdate) {
-//				FieldUpdate fu = (FieldUpdate)statement;
-//				String objId = fu.getContainerObjId();
-//				if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getContainerClassName()))) {
-//					startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_CONTAINER));
-//				}
-//				objId = fu.getValueObjId();
-//				if (objId != null && !(objId.equals("0")) && !(primitiveList.contains(fu.getValueClassName()))) {
-//					startAliasList.add(new Alias(objId, tp, Alias.OCCURRENCE_EXP_FIELD));
-//				}
-//			} else if (statement instanceof ArrayAccess) {
-//				ArrayAccess aa = (ArrayAccess)statement;
-//				String valueObjId = aa.getValueObjectId();
-//				if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(aa.getValueClassName()))) {
-//					startAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY));
-//				}				
-//			} else if (statement instanceof ArrayUpdate) {
-//				ArrayUpdate au = (ArrayUpdate)statement;
-//				String valueObjId = au.getValueObjectId();
-//				if (valueObjId != null && !(valueObjId.equals("0")) && !(primitiveList.contains(au.getValueClassName()))) {
-//					startAliasList.add(new Alias(valueObjId, tp, Alias.OCCURRENCE_EXP_ARRAY));
-//				}
-//			} else if (statement instanceof ArrayCreate) {
-//				ArrayCreate ac = (ArrayCreate)statement;
-//				String arrayObjId = ac.getArrayObjectId();
-//				if (arrayObjId != null && !(arrayObjId.equals("0")) && !(primitiveList.contains(ac.getArrayClassName()))) {
-//					startAliasList.add(new Alias(arrayObjId, tp, Alias.OCCURRENCE_EXP_RETURN));
-//				}
-//			} else if (statement instanceof MethodInvocation) {
-//				MethodExecution calledMe = ((MethodInvocation)statement).getCalledMethodExecution();
-//				String thisObjId = calledMe.getThisObjId();
-//				if (thisObjId != null && !(thisObjId.equals("0"))) {
-//					startAliasList.add(new Alias(thisObjId, tp, Alias.OCCURRENCE_EXP_RECEIVER));
-//				}
-//				List<ObjectReference> args = calledMe.getArguments();
-//				for (int j = 0; j < args.size(); j++) {
-//					ObjectReference arg = args.get(j);
-//					String argValueId = arg.getId();
-//					if (argValueId != null && !(argValueId.equals("0")) && !(primitiveList.contains(arg.getActualType()))) {
-//						startAliasList.add(new Alias(argValueId, tp, (j + Alias.OCCURRENCE_EXP_FIRST_ARG)));
-//					}
-//				}
-//				ObjectReference returnValue = calledMe.getReturnValue();
-//				if (returnValue != null) {
-//					String returnValueId = returnValue.getId();
-//					if (returnValueId != null && !(returnValueId.equals("0") && !(primitiveList.contains(returnValue.getActualType())))) {
-//						startAliasList.add(new Alias(returnValueId, tp, Alias.OCCURRENCE_EXP_RETURN));
-//					}
-//				}
-//			}
-//		}
-//		return startAliasList;
-//	}
-//
-//	public static Alias getAlias(String objectId, TracePoint occurrencePoint, int occurrenceExp) {
-//		return new Alias(objectId, occurrencePoint, occurrenceExp);
-//	}
-//	
-//	public static ArrayList<ArrayList<Alias>> getObjectFlow(Alias startAlias) {
-//		ArrayList<ArrayList<Alias>> aliasLists = new ArrayList<>();
-//		ArrayList<Alias> aliasList = new ArrayList<>();
-//		aliasLists.add(aliasList);
-////		aliasList.add(alias);
-//		String objId = startAlias.getObjectId();
-//		TracePoint tp = startAlias.getOccurrencePoint().duplicate();
-//		ArrayList<ArrayList<Alias>> resultLists = getObjectFlow(aliasLists, objId, tp, 0);
-////		for (int i = 0; i < resultLists.size(); i++) {
-////			ArrayList<Alias> resultList = resultLists.get(i);
-////			System.out.println("---------------------------------------------------------");		// �m�F�p
-////			for (Alias alias : resultList) System.out.println(alias);								// �m�F�p
-////			int lastAliasOccurrenceEXP = resultList.get(resultList.size() - 1).getOccurrenceExp();
-////			if (lastAliasOccurrenceEXP != Alias.OCCURRENCE_EXP_RETURN) {
-////				resultLists.remove(resultList); // �����̃G�C���A�X���z�񐶐���R���X�g���N�^�Ăяo���ł͂Ȃ����X�g���폜����
-////			}
-////		}
-//		return resultLists;
-//	}
-//
-//	private static ArrayList<ArrayList<Alias>> getObjectFlow(ArrayList<ArrayList<Alias>> aliasLists, 
-//			String objId, TracePoint tp, int side) {
-//		ArrayList<Alias> aliasList = aliasLists.get(aliasLists.size() - 1); // ����getObjectFlow���\�b�h���s���Ō��‚������G�C���A�X�����Ă������X�g
-//		do {
-//			Statement statement = tp.getStatement();
-//			if (statement instanceof FieldAccess) {
-//				// �t�B�[���h�Q�Ƃ̏ꍇ
-//				FieldAccess fa = (FieldAccess)statement;
-//				if (fa.getValueObjId().equals(objId)) {
-//					// ���Y�n�_�ł̃G�C���A�X�����X�g�ɒlj��������, �t�B�[���h�ŏI�X�V�ɔ�ԃp�^�[���Ƃ��̂܂ܑk��p�^�[���Ƃŕ���
-//					aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_FIELD));
-//					aliasList = new ArrayList<>(aliasList); // ���X�g���̂��f�B�[�v�R�s�[���Ă���(�t�B�[���h�ŏI�X�V�ɔ�ԍċA�����I�����, ���̂܂ܑk��p�^�[���ŗp����)
-//					TracePoint fieldUpdateTp = getRecentlyFieldUpdate(tp);
-//					aliasLists = getObjectFlow(aliasLists, objId, fieldUpdateTp, 0);
-//					aliasLists.add(aliasList); // �ċA�����ɓ���O�Ƀf�B�[�v�R�s�[���Ă������X�g���Ō���ɒlj� (�ȍ~�̑k��ɂ���Č��‚����G�C���A�X�͂��̃��X�g�ɓ������)
-//				}
-//			} else if (statement instanceof ArrayAccess) {
-//				// �z��v�f�Q�Ƃ̏ꍇ
-//				ArrayAccess aa = (ArrayAccess)statement;
-//				if (aa.getValueObjectId().equals(objId)) {
-//					aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_ARRAY));
-//					aliasList = new ArrayList<>(aliasList);
-//					TracePoint arrayUpdateTp = getRecentlyArrayUpdate(tp);
-//					aliasLists = getObjectFlow(aliasLists, objId, arrayUpdateTp, 0);
-//					aliasLists.add(aliasList);
-//				}
-//			} else if (statement instanceof ArrayCreate) {
-//				// �z�񐶐��̏ꍇ
-//				ArrayCreate ac = (ArrayCreate)statement;
-//				if (ac.getArrayObjectId().equals(objId)) {
-//					aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN)); // �z�񐶐��� new �^��[] �̖߂�l
-//					return aliasLists; // �z�񐶐��ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂�
-//				}
-//			} else if (statement instanceof MethodInvocation) {
-//				// ���\�b�h�Ăяo���̏ꍇ
-//				MethodExecution calledMethodExecution = ((MethodInvocation)statement).getCalledMethodExecution();
-//				ObjectReference returnValue = calledMethodExecution.getReturnValue();
-//				if (returnValue.getId().equals(objId)) {
-//					// �߂�l�ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ
-//					aliasList.add(new Alias(objId, tp.duplicate(), Alias.OCCURRENCE_EXP_RETURN));
-//					if (calledMethodExecution.isConstructor()) {
-//						return aliasLists; // �R���X�g���N�^�Ăяo���ӏ��̓G�C���A�X�̋N���Ȃ̂ł���ȑO�ɂ͂����Ȃ��͂�
-//					}
-//					TracePoint exitTp = calledMethodExecution.getExitPoint(); // �Ăяo�����\�b�h���s�̍ŏI�X�e�[�g�����g���w��tp���擾
-//					aliasLists = getObjectFlow(aliasLists, objId, exitTp, side + 1); // �Ăяo����̃��\�b�h���s�ɐ���
-//					aliasList = aliasLists.get(aliasLists.size() - 1);
-//				}
-//			}
-//		} while (tp.stepBackOver()); // �Ăяo�����ɖ߂邩����ȏ�H��Ȃ��Ȃ�܂Ń��[�v
-//		if (!tp.isValid()) {
-//			return aliasLists; // ����ȏチ�\�b�h���s��k��Ȃ��ꍇ(main���\�b�h�̂���ɑO�Ȃ�)�͂��̎��_�ŏI��
-//		}
-//		// --- ���̎��_�� tracePoint�� �Ăяo�������w���Ă��� (���O�܂ők���Ă������\�b�h���s�ɂ‚��Ẵ��\�b�h�Ăяo�����w���Ă���) ---
-//		MethodExecution calledMethodExecution = ((MethodInvocation)tp.getStatement()).getCalledMethodExecution();
-//		ArrayList<ObjectReference> args = calledMethodExecution.getArguments();
-//		for (int i = 0; i < args.size(); i++) {
-//			if (args.get(i).getId().equals(objId)) {
-//				// ���\�b�h�Ăяo���̎������ɃG�C���A�X�̃I�u�W�F�N�gID����v�����ꍇ
-//				aliasList.add(new Alias(objId, tp.duplicate(), (i + Alias.OCCURRENCE_EXP_FIRST_ARG)));
-//				if (side == 0) {
-//					// �T���J�n���\�b�h���s�܂��̓t�B�[���h��z��v�f�̍ŏI�X�V�T���Ŕ�񂾐�̃��\�b�h���s����, �X�^�b�N�g���[�X�ł��ǂ��S���\�b�h���s�̏ꍇ
-//					TracePoint previousTp = tp.duplicate();
-//					previousTp.stepBackOver();
-//					aliasLists = getObjectFlow(aliasLists, objId, previousTp, 0); // �Ăяo�����̃��\�b�h���s�ɖ߂�
-//				}
-//			}
-//		}
-//		return aliasLists;
-//	}
-//	
-//	public static int countMethodExecutionInTraceCollector(List<MethodExecution> methodExecutions, String targetSignature, int count, String indent) {
-//		if (methodExecutions == null || methodExecutions.isEmpty()) {
-//			return count;
-//		}
-//		for (int i = 0; i < methodExecutions.size(); i++) {
-//			MethodExecution me = methodExecutions.get(i);
-//			String signature = me.getSignature();
-////			System.out.println(indent + signature);
-//			if (targetSignature.equals(signature)) {
-//				count++;
-//			}
-//			List<MethodExecution> children = me.getChildren();
-//			count = countMethodExecutionInTraceCollector(children, targetSignature, count, indent + "--------");
-//		}
-//		return count;
-//	}
-	
-	public static void test() {
-		System.out.println("Hello TraceJSON");
-		System.out.println(getInstance().classes);
-		System.out.println("Bye TraceJSON");
-	}
-}
+}
\ No newline at end of file