diff --git a/src/LPCClocklessAnalyzer.cpp b/src/LPCClocklessAnalyzer.cpp
index c891c2f..8f10f52 100644
--- a/src/LPCClocklessAnalyzer.cpp
+++ b/src/LPCClocklessAnalyzer.cpp
@@ -48,9 +48,44 @@ void LPCClocklessAnalyzer::addFrameLabel(uint64_t start, uint64_t end, uint64_t
 	ReportProgress(end);
 }
 
+uint32_t LPCClocklessAnalyzer::readAddress() {
+		uint32_t address = 0;
+		for(int i=0; i < 4; i++) {
+			mFrame->Advance( mSamplesPerBit );
+			advanceAllToFrame();
+
+			address |= getBits() << 4 * (3-i);
+			mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
+		}
+		return address;
+}
+
+void LPCClocklessAnalyzer::skipTar() {
+	mFrame->Advance( mSamplesPerBit );
+	mFrame->Advance( mSamplesPerBit );
+}
+
+uint8_t LPCClocklessAnalyzer::readData() {
+	uint8_t data = 0;
+	mFrame->Advance( mSamplesPerBit );
+	advanceAllToFrame();
+	data = getBits();
+	mFrame->Advance( mSamplesPerBit );
+	advanceAllToFrame();
+	data |= getBits() << 4;
+	return data;
+}
+
+uint8_t LPCClocklessAnalyzer::readSync() {
+	mFrame->Advance( mSamplesPerBit );
+	advanceAllToFrame();
+	return getBits();
+}
+
 void LPCClocklessAnalyzer::WorkerThread()
 {
 	mSampleRateHz = GetSampleRate();
+	mSamplesPerBit = mSampleRateHz / (mSettings->mBitRate * 1000);
 	mFrame = GetAnalyzerChannelData( mSettings->mFrameChannel );
 	for(int i=0; i < 4; i++) {
 		mLadd[i] = GetAnalyzerChannelData( mSettings->mLaddChannel[i] );
@@ -60,14 +95,19 @@ void LPCClocklessAnalyzer::WorkerThread()
 
 
 
-// -       U32 samples_per_bit = mSampleRateHz / mSettings->mBitRate;
+// -       U32 mSamplesPerBit = mSampleRateHz / mSettings->mBitRate;
 
-	U32 samples_per_bit = mSampleRateHz / (mSettings->mBitRate * 1000);
-	std::cout << "Samples per bit: " << samples_per_bit << std::endl;
+	// mSamplesPerBit = mSampleRateHz / (mSettings->mBitRate * 1000);
+	std::cout << "Samples per bit: " << mSamplesPerBit << std::endl;
 	// U32 samples_to_first_center_of_first_data_bit = U32( 1.5 * double( mSampleRateHz ) / double( mSettings->mBitRate ) );
 
 	for( ; ; )
 	{
+
+		// Frame f;
+		// f.mType = 0x99;
+
+
 		bool is_write = false;
 
 		U8 data = 0;
@@ -77,7 +117,11 @@ void LPCClocklessAnalyzer::WorkerThread()
 		if( mFrame->GetBitState() == BIT_HIGH )
 			mFrame->AdvanceToNextEdge();
 		
-		mFrame->Advance(samples_per_bit/2);
+
+
+		uint64_t total_starting_sample = mFrame->GetSampleNumber();
+
+		mFrame->Advance(mSamplesPerBit/2);
 		advanceAllToFrame();
 		// Check pattern
 		uint8_t bits = getBits();
@@ -91,25 +135,6 @@ void LPCClocklessAnalyzer::WorkerThread()
 			ReportProgress( mFrame->GetSampleNumber() );
 			continue;
 		}
-		
-		
-		// mLadd[0]->AdvanceToAbsPosition(mFrame->GetSampleNumber());
-		// // Often the ladd lines are delayed to the actual clock transition in my testing.
-		// if( mLadd[0]->GetBitState() == BIT_HIGH ) {
-		// 	mLadd[0]->AdvanceToNextEdge();
-		// }
-
-
-		// mFrame->AdvanceToAbsPosition(mLadd[0]->GetSampleNumber());
-		// for(int i=1; i < 4; i++) {
-		// 	mLadd[i]->AdvanceToAbsPosition(mLadd[0]->GetSampleNumber());
-		// }
-		
-		// std::cout << "Advancing..." << mFrame->GetSampleNumber() << std::endl;
-		
-		// mFrame->Advance(samples_per_bit/2);
-
-		// mSerial->AdvanceToNextEdge(); //falling edge -- beginning of the start bit
 
 		U64 starting_sample = mFrame->GetSampleNumber();
 
@@ -117,71 +142,72 @@ void LPCClocklessAnalyzer::WorkerThread()
 		// Go to CYCTYPE + DIR
 		// 0000 = read
 		// 0010 = write
-		
-		mFrame->Advance( samples_per_bit );
+		mFrame->Advance( mSamplesPerBit );
 		advanceAllToFrame();
-		
+
 		uint8_t cyctype_dir = getBits();
 		if(cyctype_dir == 0x02) {
-			printf("Is write\n");
+			// printf("Is write\n");
 			is_write = true;
+			// f.is_write = true;
+		} else {
+			// f.is_write = false;
 		}
-		addFrameLabel(starting_sample, mFrame->GetSampleNumber(), cyctype_dir);
-		// Frame frame;
-		// frame.mData1 = cyctype_dir;
-		// frame.mFlags = 0;
-		// frame.mStartingSampleInclusive = starting_sample;
-		// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
-
-		// mResults->AddFrame( frame );
-		// mResults->CommitResults();
+		// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), cyctype_dir);
 		//let's put a dot exactly where we sample this bit:
 		mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
 
 		starting_sample = mFrame->GetSampleNumber();
 		// Iterate over address fields
-		uint32_t address = 0;
-		for(int i=0; i < 4; i++) {
-			mFrame->Advance( samples_per_bit );
-			advanceAllToFrame();
+		uint32_t address = readAddress();
+		// f.address = address;
+		// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), address);
 
-			address |= getBits() << 4 * (3-i);
-			mResults->AddMarker( mFrame->GetSampleNumber(), AnalyzerResults::Dot, mSettings->mFrameChannel );
+
+
+		// Read data/TAR
+		if(is_write) {
+			starting_sample = mFrame->GetSampleNumber();
+			data = readData();
+			// f.data = data;
+			// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), data);
+			skipTar();
+			starting_sample = mFrame->GetSampleNumber();
+			uint8_t sync = readSync();
+			// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), sync);
+			skipTar();
+		} else {
+			skipTar();
+			// sync field
+			starting_sample = mFrame->GetSampleNumber();
+			while(readSync() != 0) {
+				
+			}
+			// uint8_t sync = readSync();
+			// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), sync);
+
+			// data field
+			starting_sample = mFrame->GetSampleNumber();
+			data = readData();
+			// f.data = data;
+			// addFrameLabel(starting_sample, mFrame->GetSampleNumber(), data);
+
+			skipTar();
 		}
-		addFrameLabel(starting_sample, mFrame->GetSampleNumber(), address);
-		// frame.mData1 = address;
-		// frame.mFlags = 0;
-		// frame.mStartingSampleInclusive = starting_sample;
-		// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
 
-		// mResults->AddFrame( frame );
-		// mResults->CommitResults();
-
-
-		// Next bits depend on whether read or write
-
-
-
-			// if( mSerial->GetBitState() == BIT_HIGH )
-			// 	data |= mask;
-
-			// mFrame->Advance( samples_per_bit );
-
-			// mask = mask >> 1;
-		// }
-
-
-		//we have a byte to save. 
-		// Frame frame;
-		// // frame.mData1 = data;
-		// frame.mFlags = 0;
-		// frame.mStartingSampleInclusive = starting_sample;
-		// frame.mEndingSampleInclusive = mFrame->GetSampleNumber();
-
-		// mResults->AddFrame( frame );
-		// mResults->CommitResults();
-		// ReportProgress( frame.mEndingSampleInclusive );
+		uint64_t transfer =
+			((uint64_t)cyctype_dir << 40) |
+			((uint64_t)address << 8) |
+			(data);
+		
+		addFrameLabel(total_starting_sample, mFrame->GetSampleNumber(), transfer);
+		// f.mFlags = 0;
+		// f.mStartingSampleInclusive = total_starting_sample;
+		// f.mEndingSampleInclusive = mFrame->GetSampleNumber();
+		// mResults->AddFrame( f );
 
+		mResults->CommitResults();
+		ReportProgress(mFrame->GetSampleNumber());
 		mFrame->AdvanceToNextEdge();
 	}
 }
diff --git a/src/LPCClocklessAnalyzer.h b/src/LPCClocklessAnalyzer.h
index a92c810..6dd8caf 100644
--- a/src/LPCClocklessAnalyzer.h
+++ b/src/LPCClocklessAnalyzer.h
@@ -33,6 +33,7 @@ protected: //vars
 
 	//Serial analysis vars:
 	U32 mSampleRateHz;
+	U32 mSamplesPerBit;
 	U32 mStartOfStopBitOffset;
 	U32 mEndOfStopBitOffset;
 
@@ -40,6 +41,10 @@ private:
 	uint8_t getBits();
 	void advanceAllToFrame();
 	void addFrameLabel(uint64_t start, uint64_t end, uint64_t label);
+	uint32_t readAddress();
+	void skipTar();
+	uint8_t readData();
+	uint8_t readSync();
 };
 
 extern "C" ANALYZER_EXPORT const char* __cdecl GetAnalyzerName();
diff --git a/src/LPCClocklessAnalyzerResults.cpp b/src/LPCClocklessAnalyzerResults.cpp
index 649fd5e..eff240b 100644
--- a/src/LPCClocklessAnalyzerResults.cpp
+++ b/src/LPCClocklessAnalyzerResults.cpp
@@ -5,6 +5,8 @@
 #include <iostream>
 #include <fstream>
 
+
+
 LPCClocklessAnalyzerResults::LPCClocklessAnalyzerResults( LPCClocklessAnalyzer* analyzer, LPCClocklessAnalyzerSettings* settings )
 :	AnalyzerResults(),
 	mSettings( settings ),
@@ -22,8 +24,26 @@ void LPCClocklessAnalyzerResults::GenerateBubbleText( U64 frame_index, Channel&
 	Frame frame = GetFrame( frame_index );
 
 	char number_str[128];
-	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
-	AddResultString( number_str );
+	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 48, number_str, 128 );
+	AddResultString( stringForFrame(display_base, &frame).c_str() );
+}
+
+std::string LPCClocklessAnalyzerResults::stringForFrame(DisplayBase display_base, Frame *f) {
+	uint64_t data = f->mData1;
+	std::string ret = "";
+	if((data & 0xff0000000000) == 0x020000000000) {
+		ret += "WRITE ";
+	} else {
+		ret += "READ ";
+	}
+	char address[128];
+	AnalyzerHelpers::GetNumberString((f->mData1 >> 8) & 0xFFFFFFFF, display_base, 32, address, 128);
+	ret += address;
+	ret += " DATA ";
+	char data_str[8];
+	AnalyzerHelpers::GetNumberString(f->mData1 & 0xFF, display_base, 8, data_str, 8);
+	ret += data_str;
+	return ret;
 }
 
 void LPCClocklessAnalyzerResults::GenerateExportFile( const char* file, DisplayBase display_base, U32 export_type_user_id )
@@ -61,12 +81,37 @@ void LPCClocklessAnalyzerResults::GenerateExportFile( const char* file, DisplayB
 void LPCClocklessAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
 {
 #ifdef SUPPORTS_PROTOCOL_SEARCH
+	
 	Frame frame = GetFrame( frame_index );
-	ClearTabularText();
+	// if(frame.mType == 0x99) {
+	// 	LPCFrame& req( ( LPCFrame& )frame);
+	// 	if(req.is_write) {
+	// 		AddTabularText("WRTE");
+	// 	} else {
+	// 		AddTabularText("READ");
+	// 	}
 
-	char number_str[128];
-	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
-	AddTabularText( number_str );
+	// 	char number_str[128];
+	// 	AnalyzerHelpers::GetNumberString( req.address, display_base, 8, number_str, 128 );
+	// 	AddTabularText( number_str );
+
+	// 	char number_str2[128];
+	// 	AnalyzerHelpers::GetNumberString( req.data, display_base, 8, number_str2, 128 );
+	// 	AddTabularText( number_str2 );
+
+
+
+	// } else {
+		ClearTabularText();
+
+		char number_str[128];
+		// AnalyzerHelpers::GetNumberString()
+		AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 48, number_str, 128 );
+		AddTabularText( number_str );
+		AddResultString( stringForFrame(display_base, &frame).c_str() );
+		// AddTabularText("TEST");
+	// }
+	
 #endif
 }
 
diff --git a/src/LPCClocklessAnalyzerResults.h b/src/LPCClocklessAnalyzerResults.h
index 505fc97..a6d2d18 100644
--- a/src/LPCClocklessAnalyzerResults.h
+++ b/src/LPCClocklessAnalyzerResults.h
@@ -6,6 +6,14 @@
 class LPCClocklessAnalyzer;
 class LPCClocklessAnalyzerSettings;
 
+// struct LPCFrame : public Frame
+// {
+// 	bool is_write;
+// 	uint32_t address;
+// 	uint8_t sync;
+// 	uint8_t data;
+// };
+
 class LPCClocklessAnalyzerResults : public AnalyzerResults
 {
 public:
@@ -18,6 +26,7 @@ public:
 	virtual void GenerateFrameTabularText(U64 frame_index, DisplayBase display_base );
 	virtual void GeneratePacketTabularText( U64 packet_id, DisplayBase display_base );
 	virtual void GenerateTransactionTabularText( U64 transaction_id, DisplayBase display_base );
+	std::string stringForFrame(DisplayBase display_base, Frame *f);
 
 protected: //functions