diff --git a/mtp/btree.cpp b/mtp/btree.cpp
index e53afab..b73789b 100755
--- a/mtp/btree.cpp
+++ b/mtp/btree.cpp
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <utils/threads.h>
 #include "btree.hpp"
 #include "MtpDebug.h"
@@ -60,7 +59,7 @@
 }
 
 Node* Tree::findNode(MtpObjectHandle handle) {
-	std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);	
+	std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);
 	if (it != entries.end())
 		return it->second;
 	return NULL;
@@ -72,7 +71,7 @@
 }
 
 void Tree::deleteNode(MtpObjectHandle handle) {
-	std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);	
+	std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);
 	if (it != entries.end()) {
 		delete it->second;
 		entries.erase(it);
