diff --git a/indra/newview/llfloaterexploreanimations.cpp b/indra/newview/llfloaterexploreanimations.cpp
new file mode 100644
index 000000000..ec9856c18
--- /dev/null
+++ b/indra/newview/llfloaterexploreanimations.cpp
@@ -0,0 +1,310 @@
+// <edit>
+
+#include "llviewerprecompiledheaders.h"
+#include "llfloaterexploreanimations.h"
+#include "lluictrlfactory.h"
+#include "llscrolllistctrl.h"
+#include "llfloateranimpreview.h"
+#include "llvoavatar.h"
+#include "lllocalinventory.h"
+// <stuff for jelly roll>
+#include "llfloatertools.h"
+#include "llselectmgr.h"
+// </stuff for jelly roll>
+
+std::map<LLUUID, std::list<LLAnimHistoryItem*>> LLFloaterExploreAnimations::animHistory;
+LLFloaterExploreAnimations* LLFloaterExploreAnimations::sInstance;
+
+
+LLAnimHistoryItem::LLAnimHistoryItem(LLUUID assetid)
+{
+	mAssetID = assetid;
+}
+
+LLFloaterExploreAnimations::LLFloaterExploreAnimations(LLUUID avatarid)
+:	LLFloater()
+{
+	LLFloaterExploreAnimations::sInstance = this;
+	mAvatarID = avatarid;
+	mAnimPreview = new LLPreviewAnimation(256, 256);
+	mAnimPreview->setZoom(2.0f);
+	LLUICtrlFactory::getInstance()->buildFloater(this, "floater_explore_animations.xml");
+}
+
+void LLFloaterExploreAnimations::close(bool app_quitting)
+{
+	LLFloater::close(app_quitting);
+}
+
+LLFloaterExploreAnimations::~LLFloaterExploreAnimations()
+{
+	delete mAnimPreview;
+	LLFloaterExploreAnimations::sInstance = NULL;
+}
+
+BOOL LLFloaterExploreAnimations::postBuild(void)
+{
+	childSetCommitCallback("anim_list", onSelectAnimation, this);
+	childSetAction("copy_uuid_btn", onClickCopyUUID, this);
+	childSetAction("open_btn", onClickOpen, this);
+	childSetAction("jelly_roll_btn", onClickJellyRoll, this);
+	update();
+	return TRUE;
+}
+
+void LLFloaterExploreAnimations::update()
+{
+	LLScrollListCtrl* list = getChild<LLScrollListCtrl>("anim_list");
+	LLUUID selection = list->getSelectedValue().asUUID();
+	list->clearRows(); // do this differently probably
+
+	std::list<LLAnimHistoryItem*> history = animHistory[mAvatarID];
+	std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
+	std::list<LLAnimHistoryItem*>::iterator end = history.end();
+	for( ; iter != end; ++iter)
+	{
+		LLAnimHistoryItem* item = (*iter);
+
+		LLSD element;
+		element["id"] = item->mAssetID;
+
+		LLSD& name_column = element["columns"][0];
+		name_column["column"] = "name";
+		name_column["value"] = item->mAssetID.asString();
+
+		LLSD& info_column = element["columns"][1];
+		info_column["column"] = "info";
+		if(item->mPlaying)
+			info_column["value"] = "Playing";
+		else
+			info_column["value"] = llformat("%.1f min ago", (LLTimer::getElapsedSeconds() - item->mTimeStopped) / 60.f);
+
+		list->addElement(element, ADD_BOTTOM);
+	}
+
+	list->selectByID(selection);
+}
+
+void LLFloaterExploreAnimations::draw()
+{
+	LLFloater::draw();
+
+	LLRect r = getRect();
+
+	gGL.color3f(1.f, 1.f, 1.f);
+
+	gGL.getTexUnit(0)->bind(mAnimPreview->getTexture());
+
+	gGL.begin( LLRender::QUADS );
+	{
+		gGL.texCoord2f(0.f, 1.f);
+		gGL.vertex2i(r.getWidth() - 266, r.getHeight() - 25);
+		gGL.texCoord2f(0.f, 0.f);
+		gGL.vertex2i(r.getWidth() - 266, r.getHeight() - 256);
+		gGL.texCoord2f(1.f, 0.f);
+		gGL.vertex2i(r.getWidth() - 10, r.getHeight() - 256);
+		gGL.texCoord2f(1.f, 1.f);
+		gGL.vertex2i(r.getWidth() - 10, r.getHeight() - 25);
+	}
+	gGL.end();
+
+	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+
+	//LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
+	//if (!avatarp->areAnimationsPaused())
+	//{
+	//	mAnimPreview->requestUpdate();
+	//}
+}
+
+
+
+
+
+// static
+void LLFloaterExploreAnimations::startAnim(LLUUID avatarid, LLUUID assetid)
+{
+	std::string asset_str = assetid.asString();
+	if(asset_str.find("17132261-c061") != std::string::npos) return; // dog1
+	else if(asset_str.find("fea558cb-8b9b") != std::string::npos) return; // dog2
+	else if(asset_str.find("50cb5750-0743") != std::string::npos) return; // dog3
+	else if(asset_str.find("-dead-") != std::string::npos) return; // emo
+
+	LLAnimHistoryItem* item = NULL;
+
+	std::list<LLAnimHistoryItem*> history = animHistory[avatarid];
+	std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
+	std::list<LLAnimHistoryItem*>::iterator end = history.end();
+	for( ; iter != end; ++iter)
+	{
+		if((*iter)->mAssetID == assetid)
+		{
+			item = (*iter);
+			break;
+		}
+	}
+	if(!item)
+	{
+		item = new LLAnimHistoryItem(assetid);
+		item->mAvatarID = avatarid;
+		item->mTimeStarted = LLTimer::getElapsedSeconds();
+	}
+	item->mPlaying = true;
+	history.push_back(item);
+	animHistory[avatarid] = history; // is this really necessary?
+	handleHistoryChange();
+}
+
+// static
+void LLFloaterExploreAnimations::stopAnim(LLUUID avatarid, LLUUID assetid)
+{
+	std::string asset_str = assetid.asString();
+	if(asset_str.find("17132261-c061") != std::string::npos) return; // dog1
+	else if(asset_str.find("fea558cb-8b9b") != std::string::npos) return; // dog2
+	else if(asset_str.find("50cb5750-0743") != std::string::npos) return; // dog3
+	else if(asset_str.find("-dead-") != std::string::npos) return; // emo
+
+	LLAnimHistoryItem* item = NULL;
+
+	std::list<LLAnimHistoryItem*> history = animHistory[avatarid];
+	std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
+	std::list<LLAnimHistoryItem*>::iterator end = history.end();
+	for( ; iter != end; ++iter)
+	{
+		if((*iter)->mAssetID == assetid)
+		{
+			item = (*iter);
+			break;
+		}
+	}
+	if(!item)
+	{
+		item = new LLAnimHistoryItem(assetid);
+		item->mAvatarID = avatarid;
+		item->mTimeStarted = LLTimer::getElapsedSeconds();
+		history.push_back(item);
+	}
+	item->mPlaying = false;
+	item->mTimeStopped = LLTimer::getElapsedSeconds();
+	handleHistoryChange();
+}
+
+class LLAnimHistoryItemCompare
+{
+public:
+	bool operator() (LLAnimHistoryItem* first, LLAnimHistoryItem* second)
+	{
+		if(first->mPlaying)
+		{
+			if(second->mPlaying)
+			{
+				return (first->mTimeStarted > second->mTimeStarted);
+			}
+			else
+			{
+				return true;
+			}
+		}
+		else if(second->mPlaying)
+		{
+			return false;
+		}
+		else
+		{
+			return (first->mTimeStopped > second->mTimeStopped);
+		}
+	}
+};
+
+// static
+void LLFloaterExploreAnimations::handleHistoryChange()
+{
+	std::map<LLUUID, std::list<LLAnimHistoryItem*>>::iterator av_iter = animHistory.begin();
+	std::map<LLUUID, std::list<LLAnimHistoryItem*>>::iterator av_end = animHistory.end();
+	for( ; av_iter != av_end; ++av_iter)
+	{
+		std::list<LLAnimHistoryItem*> history = (*av_iter).second;
+
+		// Sort it
+		LLAnimHistoryItemCompare c;
+		history.sort(c);
+
+		// Remove dupes
+		history.unique();
+
+		// Trim it
+		if(history.size() > 32)
+		{
+			history.resize(32);
+		}
+
+		animHistory[(*av_iter).first] = history;
+	}
+
+	// Update floater
+	if(LLFloaterExploreAnimations::sInstance)
+		LLFloaterExploreAnimations::sInstance->update();
+}
+
+
+
+
+
+// static
+void LLFloaterExploreAnimations::onSelectAnimation(LLUICtrl* ctrl, void* user_data)
+{
+	LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)user_data;
+	LLPreviewAnimation* preview = (LLPreviewAnimation*)floater->mAnimPreview;
+	LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
+	LLUUID selection = list->getSelectedValue().asUUID();
+	
+	preview->getDummyAvatar()->deactivateAllMotions();
+	preview->getDummyAvatar()->startMotion(selection, 0.f);
+	preview->setZoom(2.0f);
+}
+
+// static
+void LLFloaterExploreAnimations::onClickCopyUUID(void* data)
+{
+	LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
+	LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
+	LLUUID selection = list->getSelectedValue().asUUID();
+	gViewerWindow->mWindow->copyTextToClipboard(utf8str_to_wstring(selection.asString()));
+}
+
+void LLFloaterExploreAnimations::onClickOpen(void* data)
+{
+	LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
+	LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
+	LLUUID selection = list->getSelectedValue().asUUID();
+	LLUUID item = LLLocalInventory::addItem(selection.asString(), LLAssetType::AT_ANIMATION, selection, true);
+}
+
+void LLFloaterExploreAnimations::onClickJellyRoll(void* data)
+{
+	std::string hover_text;
+	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
+	LLObjectSelection::valid_iterator sel_it = selection->valid_begin();
+	LLObjectSelection::valid_iterator sel_end = selection->valid_end();
+	for( ; sel_it != sel_end; ++sel_it)
+	{
+		LLViewerObject* objectp = (*sel_it)->getObject();
+		hover_text = objectp->getDebugText();
+		if(hover_text != "")
+		{
+			break;
+		}
+	}
+
+	LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
+	LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
+	LLUUID anim_id = list->getSelectedValue().asUUID();
+	
+	LLFloaterNewLocalInventory* createy = new LLFloaterNewLocalInventory();
+	createy->childSetText("name_line", hover_text);
+	createy->childSetText("asset_id_line", anim_id.asString());
+	createy->childSetValue("type_combo", "animatn");
+	createy->childSetText("creator_id_line", LLFloaterNewLocalInventory::sLastCreatorId.asString());
+}
+
+// </edit>
diff --git a/indra/newview/llfloaterexploreanimations.h b/indra/newview/llfloaterexploreanimations.h
new file mode 100644
index 000000000..2c1070f93
--- /dev/null
+++ b/indra/newview/llfloaterexploreanimations.h
@@ -0,0 +1,58 @@
+// <edit>
+#ifndef LL_LLFLOATEREXPLOREANIMATIONS_H
+#define LL_LLFLOATEREXPLOREANIMATIONS_H
+
+#include "llfloater.h"
+#include "llfloateranimpreview.h"
+#include "llviewerwindow.h" // gViewerWindow
+
+class LLAnimHistoryItem
+{
+public:
+	LLAnimHistoryItem(LLUUID assetid);
+
+	LLUUID mAvatarID;
+	LLUUID mAssetID;
+	bool mPlaying;
+	F64 mTimeStarted;
+	F64 mTimeStopped;
+};
+
+class LLFloaterExploreAnimations
+: public LLFloater
+{
+public:
+	LLFloaterExploreAnimations(LLUUID avatarid);
+	BOOL postBuild(void);
+	void close(bool app_quitting);
+
+	void update();
+
+	LLUUID mAvatarID;
+	LLPreviewAnimation* mAnimPreview;
+
+private:
+	virtual ~LLFloaterExploreAnimations();
+
+
+// static stuff!
+public:
+	static void onSelectAnimation(LLUICtrl* ctrl, void* user_data);
+	static void onClickCopyUUID(void* data);
+	static void onClickOpen(void* data);
+	static void onClickJellyRoll(void* data);
+
+	static void startAnim(LLUUID avatarid, LLUUID assetid);
+	static void stopAnim(LLUUID avatarid, LLUUID assetid);
+
+	static std::map<LLUUID, std::list<LLAnimHistoryItem*>> animHistory;
+	static LLFloaterExploreAnimations* sInstance;
+private:
+	static void handleHistoryChange();
+
+protected:
+	void			draw();
+};
+
+#endif
+// </edit>
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index 555efc114..b8a49ed4b 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -3715,8 +3715,6 @@ std::string LLObjectBridge::getLabelSuffix() const
 		LLStringUtil::toLower(attachment_point_name);
 		return LLItemBridge::getLabelSuffix() + std::string(" (worn on ") + attachment_point_name + std::string(")");
 	}
-	else
-	{
 	else
 	{
 		// <edit> testzone attachpt
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index 578fdd823..936c99bde 100644
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -59,6 +59,10 @@
 #include "llviewercontrol.h"
 #include "llvoavatar.h"
 #include "llsdutil.h"
+// <edit>
+#include "llimportobject.h"
+#include "llappviewer.h" // gLostItemsRoot
+// </edit>
 #include <deque>
 
 //#define DIFF_INVENTORY_FILES
@@ -207,6 +211,14 @@ BOOL LLInventoryModel::isObjectDescendentOf(const LLUUID& obj_id,
 	while(obj)
 	{
 		const LLUUID& parent_id = obj->getParentUUID();
+		// <edit>
+		if(parent_id == obj->getUUID())
+		{
+			// infinite loop... same thing as having no parent, hopefully.
+			llwarns << "This shit has itself as parent! " << parent_id.asString() << ", " << obj->getName() << llendl;
+			return FALSE;
+		}
+		// </edit>
 		if( parent_id.isNull() )
 		{
 			return FALSE;
@@ -823,12 +835,14 @@ void LLInventoryModel::deleteObject(const LLUUID& id)
 // folders, items, etc in a fairly efficient manner.
 void LLInventoryModel::purgeDescendentsOf(const LLUUID& id)
 {
-	EHasChildren children = categoryHasChildren(id);
-	if(children == CHILDREN_NO)
-	{
-		llinfos << "Not purging descendents of " << id << llendl;
-		return;
-	}
+	// <edit> "Deliberately disobeying you" derf derf
+	//EHasChildren children = categoryHasChildren(id);
+	//if(children == CHILDREN_NO)
+	//{
+	//	llinfos << "Not purging descendents of " << id << llendl;
+	//	return;
+	//}
+	// </edit>
 	LLPointer<LLViewerInventoryCategory> cat = getCategory(id);
 	if(cat.notNull())
 	{
@@ -1383,41 +1397,48 @@ void LLInventoryModel::bulkFetch(std::string url)
 		
 		    if (cat)
 		    {
-			    if ( LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
-			    {
-				    LLSD folder_sd;
-				    folder_sd["folder_id"]		= cat->getUUID();
-				    folder_sd["owner_id"]		= cat->getOwnerID();
-				    folder_sd["sort_order"]		= (LLSD::Integer)sort_order;
-				    folder_sd["fetch_folders"]	= TRUE; //(LLSD::Boolean)sFullFetchStarted;
-				    folder_sd["fetch_items"]	= (LLSD::Boolean)TRUE;
-				    
-					LL_DEBUGS("Inventory") << " fetching "<<cat->getUUID()<<" with cat owner "<<cat->getOwnerID()<<" and agent" << gAgent.getID() << LL_ENDL;
-				    //OGPX if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
-					// for OGP it really doesnt make sense to have the decision about whether to fetch
-					// from the library or user cap be determined by a hard coded UUID. 
-					// if it isnt an item that belongs to the agent, then fetch from the library
-					if (gAgent.getID() != cat->getOwnerID()) //if i am not the owner, it must be in the library
-					    body_lib["folders"].append(folder_sd);
-				    else
-					    body["folders"].append(folder_sd);
-				    folder_count++;
-			    }
-			    if (sFullFetchStarted)
-			    {	//Already have this folder but append child folders to list.
-				    // add all children to queue
-				    parent_cat_map_t::iterator cat_it = gInventory.mParentChildCategoryTree.find(cat->getUUID());
-				    if (cat_it != gInventory.mParentChildCategoryTree.end())
-				    {
-					    cat_array_t* child_categories = cat_it->second;
-    
-					    for (S32 child_num = 0; child_num < child_categories->count(); child_num++)
-					    {
-						    sFetchQueue.push_back(child_categories->get(child_num)->getUUID());
-					    }
-				    }
-    
-			    }
+				// <edit> Pre-emptive strike
+				if(!(gInventory.isObjectDescendentOf(cat->getUUID(), gLocalInventoryRoot)))
+				{
+				// </edit>
+					if ( LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
+					{
+						LLSD folder_sd;
+						folder_sd["folder_id"]		= cat->getUUID();
+						folder_sd["owner_id"]		= cat->getOwnerID();
+						folder_sd["sort_order"]		= (LLSD::Integer)sort_order;
+						folder_sd["fetch_folders"]	= TRUE; //(LLSD::Boolean)sFullFetchStarted;
+						folder_sd["fetch_items"]	= (LLSD::Boolean)TRUE;
+						
+						LL_DEBUGS("Inventory") << " fetching "<<cat->getUUID()<<" with cat owner "<<cat->getOwnerID()<<" and agent" << gAgent.getID() << LL_ENDL;
+						//OGPX if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
+						// for OGP it really doesnt make sense to have the decision about whether to fetch
+						// from the library or user cap be determined by a hard coded UUID. 
+						// if it isnt an item that belongs to the agent, then fetch from the library
+						if (gAgent.getID() != cat->getOwnerID()) //if i am not the owner, it must be in the library
+							body_lib["folders"].append(folder_sd);
+						else
+							body["folders"].append(folder_sd);
+						folder_count++;
+					}
+					if (sFullFetchStarted)
+					{	//Already have this folder but append child folders to list.
+						// add all children to queue
+						parent_cat_map_t::iterator cat_it = gInventory.mParentChildCategoryTree.find(cat->getUUID());
+						if (cat_it != gInventory.mParentChildCategoryTree.end())
+						{
+							cat_array_t* child_categories = cat_it->second;
+		
+							for (S32 child_num = 0; child_num < child_categories->count(); child_num++)
+							{
+								sFetchQueue.push_back(child_categories->get(child_num)->getUUID());
+							}
+						}
+		
+					}
+				// <edit>
+				}
+				// </edit>
 		    }
         }
 		sFetchQueue.pop_front();
@@ -1718,7 +1739,10 @@ void LLInventoryModel::addItem(LLViewerInventoryItem* item)
 	if(item)
 	{
 		mItemMap[item->getUUID()] = item;
-		//mInventory[item->getUUID()] = item;
+		// <edit>
+		if(LLXmlImport::sImportInProgress)
+			LLXmlImport::onNewItem(item);
+		// </edit>
 	}
 }
 
@@ -1903,6 +1927,11 @@ bool LLInventoryModel::isCategoryComplete(const LLUUID& cat_id) const
 			return true;
 		}
 	}
+
+	// <edit>
+	if((cat_id == gLocalInventoryRoot) || gInventory.isObjectDescendentOf(cat_id, gLocalInventoryRoot)) return true;
+	// </edit>
+
 	return false;
 }
 
@@ -3457,9 +3486,11 @@ bool LLInventoryCollectFunctor::itemTransferCommonlyAllowed(LLInventoryItem* ite
 
 	switch(item->getType())
 	{
-	case LLAssetType::AT_CALLINGCARD:
-		// not allowed
-		break;
+	{
+	// <edit> I don't even think changing this did anything
+	//case LLAssetType::AT_CALLINGCARD:
+	//	// not allowed
+	//	break;
 		
 	case LLAssetType::AT_OBJECT:
 		my_avatar = gAgent.getAvatarObject();
diff --git a/indra/newview/llinventorymodel.h b/indra/newview/llinventorymodel.h
index 06ee98dff..e4cd1b24b 100644
--- a/indra/newview/llinventorymodel.h
+++ b/indra/newview/llinventorymodel.h
@@ -385,8 +385,14 @@ protected:
 	// the internal data structures are consistent. These methods
 	// should be passed pointers of newly created objects, and the
 	// instance will take over the memory management from there.
+// <edit>
+public:
+// </edit>
 	void addCategory(LLViewerInventoryCategory* category);
 	void addItem(LLViewerInventoryItem* item);
+// <edit>
+protected:
+// </edit>
 
 	// Internal method which looks for a category with the specified
 	// preferred type. Returns LLUUID::null if not found
@@ -402,12 +408,18 @@ protected:
 	//void recalculateCloneInformation();
 
 	// file import/export.
+// <edit>
+public:
+// </edit>
 	static bool loadFromFile(const std::string& filename,
 							 cat_array_t& categories,
 							 item_array_t& items); 
 	static bool saveToFile(const std::string& filename,
 						   const cat_array_t& categories,
 						   const item_array_t& items); 
+// <edit>
+protected:
+// </edit>
 
 	// message handling functionality
 	//static void processUseCachedInventory(LLMessageSystem* msg, void**);
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 8f77c4f45..ee8833004 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -83,6 +83,11 @@
 #include "llvoiceclient.h"
 #include "llvoicevisualizer.h" // Ventrella
 
+// <edit>
+#include "llfloaterexploreanimations.h"
+//#include "llao.h"
+// </edit>
+
 #if LL_MSVC
 // disable boost::lexical_cast warning
 #pragma warning (disable:4702)
@@ -747,7 +752,14 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
 	mNeedsSkin(FALSE),
 	mUpdatePeriod(1),
 	mFullyLoadedInitialized(FALSE),
-	mHasBakedHair( FALSE )
+	mHasBakedHair( FALSE ),
+	// <edit>
+	mNametagSaysIdle(false),
+	mIdleForever(true),
+	mIdleMinutes(0),
+	mFocusObject(LLUUID::null),
+	mFocusVector(LLVector3d::zero)
+	// </edit>
 {
 	LLMemType mt(LLMemType::MTYPE_AVATAR);
 	//VTResume();  // VTune
@@ -3061,9 +3073,11 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 					new_name = TRUE;
 				}
 				
-				LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
-				avatar_name_color.setAlpha(alpha);
-				mNameText->setColor(avatar_name_color);
+				}
+				
+				// <edit>
+				//LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
+				//avatar_name_color.setAlpha(alpha);
 				
 				LLQuaternion root_rot = mRoot.getWorldRotation();
 				mNameText->setUsePixelSize(TRUE);
@@ -3144,6 +3158,108 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
 				line += lastname->getString();
 				BOOL need_comma = FALSE;
 
+				BOOL need_comma = FALSE;
+
+				// <edit>
+				if(getTEImage(TEX_HEAD_BODYPAINT)->isMissingAsset())
+				{
+					mNameText->setColor(LLColor4(1.f, 1.0f, 1.0f));
+					strcat(line, " (Unknown viewer)");
+				}
+				else
+				{
+					std::string uuid_str = getTEImage(TEX_HEAD_BODYPAINT)->getID().asString();
+
+					if(uuid_str == "ccda2b3b-e72c-a112-e126-fee238b67218")
+					{
+						// textures other than head are 4934f1bf-3b1f-cf4f-dbdf-a72550d05bc6
+						mNameText->setColor(LLColor4(0.f, 1.0f, 0.0f));
+						strcat(line, " (Emerald)");
+					}
+					else if(uuid_str == "0bcd5f5d-a4ce-9ea4-f9e8-15132653b3d8")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
+						strcat(line, " (MoyMix)");
+					}
+					else if(uuid_str == "5855f37d-63e5-3918-1404-8ffa3820eb6d")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
+						strcat(line, " (MoyMix/B)");
+					}
+					else if(uuid_str == "9ba526b6-f43d-6b60-42de-ce62a25ee7fb")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
+						strcat(line, " (MoyMix/nolife)");
+					}
+					//else if(uuid_str == "abbca853-30ba-49c1-a1e7-2a5b9a70573f")
+					//{
+					//	mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
+					//	strcat(line, " (CryoLife/" + "A)");
+					//}
+					else if(uuid_str == "0f6723d2-5b23-6b58-08ab-308112b33786")
+					{
+						mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
+						strcat(line, " (CryoLife)");
+					}
+					else if(uuid_str == "2c9c1e0b-e5d1-263e-16b1-7fc6d169f3d6")
+					{
+						mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
+						strcat(line, " (Phoxy SL)");
+					}
+					else if(uuid_str == "c252d89d-6f7c-7d90-f430-d140d2e3fbbe")
+					{
+						mNameText->setColor(LLColor4(0.7f, 0.7f, 0.7f));
+						strcat(line, " (VLife)");
+					}
+					else if(uuid_str == "5aa5c70d-d787-571b-0495-4fc1bdef1500")
+					{
+						mNameText->setColor(LLColor4(1.f, 0.0f, 0.0f));
+						strcat(line, " (GridProxy/LordGregGreg)");
+					}
+					else if(uuid_str == "8183e823-c443-2142-6eb6-2ab763d4f81c")
+					{
+						mNameText->setColor(LLColor4(1.f, 1.f, 0.0f));
+						strcat(line, " (GridProxy/DayOh)");
+					}
+					else if(uuid_str == "f3fd74a6-fee7-4b2f-93ae-ddcb5991da04")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.0f, 1.0f));
+						strcat(line, " (PSL/A)");
+					}
+					else if(uuid_str == "77662f23-c77a-9b4d-5558-26b757b2144c")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.0f, 1.0f));
+						strcat(line, " (PSL/B)");
+					}
+					else if(uuid_str == "1c29480c-c608-df87-28bb-964fb64c5366")
+					{
+						mNameText->setColor(LLColor4(1.f, 1.0f, 1.0f));
+						strcat(line, " (Emerald/GEMINI)");
+					}
+					else if(uuid_str == "5262d71a-88f7-ef40-3b15-00ea148ab4b5")
+					{
+						mNameText->setColor(LLColor4(0.9f, 0.9f, 0.9f));
+						strcat(line, " (GEMINI Bot)");
+					}
+					else if(uuid_str == "adcbe893-7643-fd12-f61c-0b39717e2e32")
+					{
+						mNameText->setColor(LLColor4(1.0f, 0.5f, 0.4f));
+						strcat(line, " (tyk3n)");
+					}
+					else if(uuid_str == "f5a48821-9a98-d09e-8d6a-50cc08ba9a47")
+					{
+						mNameText->setColor(gColors.getColor( "AvatarNameColor" ));
+						strcat(line, " (NeilLife)");
+					}
+					
+					else
+					{
+						LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
+						avatar_name_color.setAlpha(1.f);
+						mNameText->setColor(avatar_name_color);
+					}
+				}
+				// </edit>
 				if (is_away || is_muted || is_busy)
 				{
 					line += " (";
@@ -3301,6 +3417,14 @@ void LLVOAvatar::idleUpdateTractorBeam()
 	{
 		return;
 	}
+
+	// <edit>
+	if(gSavedSettings.getBOOL("DisablePointAtAndBeam"))
+	{
+		return;
+	}
+	// </edit>
+
 	const LLPickInfo& pick = gViewerWindow->getLastPick();
 
 	// No beam for media textures
@@ -4729,6 +4853,9 @@ void LLVOAvatar::processAnimationStateChanges()
 		if (found_anim == mSignaledAnimations.end())
 		{
 			processSingleAnimationStateChange(anim_it->first, FALSE);
+			// <edit>
+			LLFloaterExploreAnimations::stopAnim(getID(), anim_it->first);
+			// </edit>
 			mPlayingAnimations.erase(anim_it++);
 			continue;
 		}
@@ -4744,6 +4871,9 @@ void LLVOAvatar::processAnimationStateChanges()
 		// signaled but not playing, or different sequence id, start motion
 		if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second)
 		{
+			// <edit>
+			LLFloaterExploreAnimations::startAnim(getID(), anim_it->first);
+			// </edit>
 			if (processSingleAnimationStateChange(anim_it->first, TRUE))
 			{
 				mPlayingAnimations[anim_it->first] = anim_it->second;
@@ -5983,9 +6113,43 @@ LLViewerJointAttachment* LLVOAvatar::getTargetAttachmentPoint(LLViewerObject* vi
 // attachObject()
 //-----------------------------------------------------------------------------
 BOOL LLVOAvatar::attachObject(LLViewerObject *viewer_object)
-{
-	LLViewerJointAttachment* attachment = getTargetAttachmentPoint(viewer_object);
-
+{
+	LLViewerJointAttachment* attachment = getTargetAttachmentPoint(viewer_object);
+
+	// <edit> testzone attachpt
+	if(!attachment)
+	{
+		S32 attachmentID = ATTACHMENT_ID_FROM_STATE(viewer_object->getState());
+		LLUUID item_id;
+		LLNameValue* item_id_nv = viewer_object->getNVPair("AttachItemID");
+		if( item_id_nv )
+		{
+			const char* s = item_id_nv->getString();
+			if(s)
+				item_id.set(s);
+		}
+		if(!item_id.isNull())
+		{
+			mUnsupportedAttachmentPoints[attachmentID] = item_id;
+			if (viewer_object->isSelected())
+			{
+				LLSelectMgr::getInstance()->updateSelectionCenter();
+				LLSelectMgr::getInstance()->updatePointAt();
+			}
+
+			if (mIsSelf)
+			{
+				updateAttachmentVisibility(gAgent.getCameraMode());
+				
+				// Then make sure the inventory is in sync with the avatar.
+				gInventory.addChangedMask( LLInventoryObserver::LABEL, item_id );
+				gInventory.notifyObservers();
+			}
+		}
+		else
+			llwarns << "No item ID" << llendl;
+	}
+	// </edit>
 	if (!attachment || !attachment->addObject(viewer_object))
 	{
 		return FALSE;
@@ -6094,8 +6258,57 @@ BOOL LLVOAvatar::detachObject(LLViewerObject *viewer_object)
 			}
 			return TRUE;
 		}
-	}
-
+	}
+
+	// <edit> testzone attachpt
+	LLUUID item_id;
+	LLNameValue* item_id_nv = viewer_object->getNVPair("AttachItemID");
+	if( item_id_nv )
+	{
+		const char* s = item_id_nv->getString();
+		if(s)
+			item_id.set(s);
+	}
+	if(!item_id.isNull())
+	{
+		std::map<S32, LLUUID>::iterator iter = mUnsupportedAttachmentPoints.begin();
+		std::map<S32, LLUUID>::iterator end = mUnsupportedAttachmentPoints.end();
+		for( ; iter != end; ++iter)
+		{
+			if((*iter).second == item_id)
+			{
+				mUnsupportedAttachmentPoints.erase((*iter).first);
+				if (mIsSelf)
+				{
+					// the simulator should automatically handle
+					// permission revocation
+
+					stopMotionFromSource(viewer_object->getID());
+					LLFollowCamMgr::setCameraActive(viewer_object->getID(), FALSE);
+
+					LLViewerObject::const_child_list_t& child_list = viewer_object->getChildren();
+					for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
+						 iter != child_list.end(); iter++)
+					{
+						LLViewerObject* child_objectp = *iter;
+						// the simulator should automatically handle
+						// permissions revocation
+
+						stopMotionFromSource(child_objectp->getID());
+						LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE);
+					}
+					// Then make sure the inventory is in sync with the avatar.
+					gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
+					gInventory.notifyObservers();
+				}
+				return TRUE;
+			}
+		}
+		llwarns << "Not found" << llendl;
+	}
+	else
+		llwarns << "No item ID" << llendl;
+	// </edit>
 	
 	return FALSE;
 }
@@ -6257,8 +6470,16 @@ BOOL LLVOAvatar::isWearingAttachment( const LLUUID& inv_item_id )
 		}
 	}
 	return FALSE;
-}
-
+}
+
+// <edit> testzone attachpt
+BOOL LLVOAvatar::isWearingUnsupportedAttachment( const LLUUID& inv_item_id )
+{
+	std::map<S32, LLUUID>::iterator end = mUnsupportedAttachmentPoints.end();
+	for(std::map<S32, LLUUID>::iterator iter = mUnsupportedAttachmentPoints.begin(); iter != end; ++iter)
+		if((*iter).second == inv_item_id)
+			return TRUE;
+	return FALSE;
 //-----------------------------------------------------------------------------
 // getWornAttachment()
 //-----------------------------------------------------------------------------
@@ -8508,8 +8729,11 @@ void LLVOAvatar::dumpLocalTextures()
 
 				llinfos << "LocTex " << name << ": "
 						<< "Discard " << image->getDiscardLevel() << ", "
-						<< "(" << image->getWidth() << ", " << image->getHeight() << ") " 
-#if !LL_RELEASE_FOR_DOWNLOAD
+						<< "(" << image->getWidth() << ", " << image->getHeight() << ") " 
+// <edit>
+//#if !LL_RELEASE_FOR_DOWNLOAD
+#if 1
+// </edit>
 					// End users don't get to trivially see avatar texture IDs,
 					// makes textures easier to steal
 						<< image->getID() << " "
diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index d4417ea7b..d116fb58f 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -283,6 +283,9 @@ public:
 	void getOffObject();
 
 	BOOL isWearingAttachment( const LLUUID& inv_item_id );
+	// <edit> testzone attachpt
+	BOOL isWearingUnsupportedAttachment( const LLUUID& inv_item_id );
+	// </edit>
 	LLViewerObject* getWornAttachment( const LLUUID& inv_item_id );
 	const std::string getAttachedPointName(const LLUUID& inv_item_id);
 
@@ -578,6 +581,10 @@ private:
 	const static LLUUID	sStepSounds[LL_MCODE_END];
 	const static LLUUID	sStepSoundOnLand;
 
+	// <edit>
+	std::map<S32, LLUUID> mUnsupportedAttachmentPoints;
+	// </edit>
+
 	// Xml parse tree of avatar config file
 	static LLXmlTree sXMLTree;
 	// Xml parse tree of avatar skeleton file
@@ -678,32 +685,15 @@ protected:
 	S32				getLocalDiscardLevel(LLVOAvatarDefines::ETextureIndex index);
 public:
 	static void updateFreezeCounter(S32 counter = 0 );
-private:
-	static S32 sFreezeCounter;
-	
-	//-----------------------------------------------------------------------------------------------
-	// Avatar skeleton setup.
-	//-----------------------------------------------------------------------------------------------
-private:
-	BOOL loadAvatar();
-	BOOL setupBone(const LLVOAvatarBoneInfo* info, LLViewerJoint* parent, S32 &current_volume_num, S32 &current_joint_num);
-	BOOL buildSkeleton(const LLVOAvatarSkeletonInfo *info);
-
-	//-----------------------------------------------------------------------------------------------
-	// Per-avatar information about texture data.
-	// To-do: Move this to private implementation class
-	//-----------------------------------------------------------------------------------------------
-private:
-	struct BakedTextureData
-	{
-		LLUUID			mLastTextureIndex;
-		LLTexLayerSet*	mTexLayerSet;
-		bool			mIsLoaded;
-		bool			mIsUsed;
-		LLVOAvatarDefines::ETextureIndex	mTextureIndex;
-		U32				mMaskTexName;
-		// Stores pointers to the joint meshes that this baked texture deals with
-		std::vector< LLViewerJointMesh * > mMeshes;  // std::vector<LLViewerJointMesh> mJoints[i]->mMeshParts
+// <edit>
+	//bool mNametagSaysIdle;
+	//bool mIdleForever;
+	//LLFrameTimer mIdleTimer;
+	//U32 mIdleMinutes;
+	LLUUID mFocusObject;
+	LLVector3d mFocusVector;
+	//void resetIdleTime();
+// </edit>
 	};
 	typedef std::vector<BakedTextureData> bakedtexturedata_vec_t;
 	bakedtexturedata_vec_t mBakedTextureData;