//private static Dictionary<string, Action<UUID>> UUID2Memeber = new Dictionary<string, Action<UUID>>();
        private static void GetUUIDType(MemberInfo info, object ob)
        {
            var o = ob as UUID?;

            if (!o.HasValue)
            {
                return;
            }
            if (o == UUID.Zero)
            {
                return;
            }
            string name = info.Name;

            if (name == "ID" || name == "UUID" || name == "AssetID")
            {
                name = info.DeclaringType.Name;
            }
            UUIDGleaner act = GetUUIDGleaner(name, info);

            act(o.Value, null);
        }
        static UUIDGleaner GetUUIDGleaner(string p, MemberInfo info)
        {
            lock (UUID2Type)
                if (UUID2Type.Count == 0)
                {
                    UUIDGleaner texture  = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Texture); });
                    UUIDGleaner avatar   = ((obj, sim) => { GridMaster.DeclareAvatarProfile(obj); });
                    UUIDGleaner task     = ((obj, sim) => { GridMaster.DeclareTask(obj, sim); });
                    UUIDGleaner nothing  = ((obj, sim) => { });
                    UUIDGleaner objectID = ((obj, sim) => { GridMaster.CreateSimObject(obj, GridMaster, sim); });
                    UUIDGleaner role     = ((obj, sim) => DeclareGeneric("GroupRole", obj, " +p"));
                    UUID2Type[""]          = nothing;
                    UUID2Type["ID"]        = nothing;
                    UUID2Type["Sound"]     = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Sound); });
                    UUID2Type["Gesture"]   = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Gesture); });
                    UUID2Type["Landmark"]  = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Landmark); });
                    UUID2Type["Animation"] = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Animation); });
                    UUID2Type["Clothing"]  = ((obj, sim) => { SimAssetStore.FindOrCreateAsset(obj, AssetType.Clothing); });
                    UUID2Type["Region"]    = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(SimRegion)); });
                    UUID2Type["Estate"]    = ((obj, sim) => { RegisterUUIDMaybe(obj, typeof(EstateAssetType)); });
                    UUID2Type["Image"]
                                           = UUID2Type["SculptTexture"]
                                           = UUID2Type["Photo"]
                                           = UUID2Type["Insignia"]
                                           = UUID2Type["Picture"]
                                           = UUID2Type["Texture"]
                                           = UUID2Type["Sculpt"]
                                           = UUID2Type["ProfileImage"] = texture;
                    UUID2Type["Owner"]     = UUID2Type["Partner"] = UUID2Type["Creator"] = UUID2Type["Founder"] = avatar;
                    UUID2Type["Group"]     = ((obj, sim) => { GridMaster.DeclareGroup(obj); });
                    UUID2Type["Object"]    = objectID;
                    UUID2Type["Primitive"] = objectID;
                    // todo inventory item
                    UUID2Type["OwnerRole"] = role;
                    UUID2Type["FromTask"]  = task;
                    UUID2Type["FolderID"]  = nothing;
                    UUID2Type["ItemID"]    = nothing;
                    // ussualyl objects but need to confirm: The Key of the specified target object or avatar particles will follow"
                    UUID2Type["Target"] = nothing;
                    UUID2Type["Asset"]  = nothing;
                }
            UUIDGleaner o;

            lock (UUID2Type)
            {
                if (UUID2Type.TryGetValue(p, out o))
                {
                    return(o);
                }
                foreach (var s in new[] { "From", "To", "Next", "Last", "First", "Second", "Life", "Life", })
                {
                    if (p.StartsWith(s))
                    {
                        return(UUID2Type[p] = GetUUIDGleaner(p.Substring(s.Length), info));
                    }
                }
                foreach (var s in new[] { "ID", "UUID", "Asset" })
                {
                    if (p.EndsWith(s))
                    {
                        return(UUID2Type[p] = GetUUIDGleaner(p.Substring(0, p.Length - s.Length), info));
                    }
                }
                Debug("Dont know what UUID means in " + p);
                return((obj, sim) => { RegisterUUIDMaybe(obj, info); });
            }
        }