diff --git a/main.go b/main.go
index 9dc9753..fcadab3 100644
--- a/main.go
+++ b/main.go
@@ -41,6 +41,28 @@ type VersionPath struct {
 	Version        string
 }
 
+type RoomInfoTree map[id.RoomID](*RoomInfo)
+
+type RoomInfo struct {
+	MaxRoomVersions map[string](*MaxRoomVersionInfo)
+}
+
+type MaxRoomVersionInfo struct {
+	Servers map[string](*ServerInfo)
+}
+
+type ServerInfo struct {
+	Versions map[string](*VersionInfo)
+}
+
+type VersionInfo struct {
+	Homeservers map[string](*HomeserverInfo)
+}
+
+type HomeserverInfo struct {
+	MemberCount uint
+}
+
 var unknownServerVersionInfo = fclient.Version{
 	Server: struct {
 		Name    string `json:"name"`
@@ -362,7 +384,7 @@ func main() {
 	serverVersionInfoByHomeserver := getServerVersionInfoByHomeserver(homeservers, federationClient)
 
 	// Info map tree.
-	roomMaxVersionInfos := make(map[id.RoomID](map[string](map[string](map[string](map[string]uint)))))
+	roomInfoTree := make(RoomInfoTree)
 	// Member counters.
 	membersByRoomID := make(map[id.RoomID]uint)
 	membersByMaxRoomVersion := make(map[MaxRoomVersionPath]uint)
@@ -381,77 +403,82 @@ func main() {
 			membersByServerPath[ServerPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name}] += members
 			membersByVersionPath[VersionPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name, serverVersionInfo.Server.Version}] += members
 
-			// Sort into roomMaxVersionInfos map tree.
-			maxRoomVersionMap, ok := roomMaxVersionInfos[roomID]
+			// Sort into roomInfoTree.
+			roomInfo, ok := roomInfoTree[roomID]
 			if !ok {
-				maxRoomVersionMap = make(map[string](map[string](map[string](map[string]uint))))
-				roomMaxVersionInfos[roomID] = maxRoomVersionMap
+				roomInfo = &RoomInfo{MaxRoomVersions: make(map[string]*MaxRoomVersionInfo)}
+				roomInfoTree[roomID] = roomInfo
 			}
-			serverMap, ok := maxRoomVersionMap[maxRoomVersion]
+			maxRoomVersionInfo, ok := roomInfo.MaxRoomVersions[maxRoomVersion]
 			if !ok {
-				serverMap = make(map[string](map[string](map[string]uint)))
-				maxRoomVersionMap[maxRoomVersion] = serverMap
+				maxRoomVersionInfo = &MaxRoomVersionInfo{Servers: make(map[string]*ServerInfo)}
+				roomInfo.MaxRoomVersions[maxRoomVersion] = maxRoomVersionInfo
 			}
-			versionMap, ok := serverMap[serverVersionInfo.Server.Name]
+			serverInfo, ok := maxRoomVersionInfo.Servers[serverVersionInfo.Server.Name]
 			if !ok {
-				versionMap = make(map[string](map[string]uint))
-				serverMap[serverVersionInfo.Server.Name] = versionMap
+				serverInfo = &ServerInfo{Versions: make(map[string]*VersionInfo)}
+				maxRoomVersionInfo.Servers[serverVersionInfo.Server.Name] = serverInfo
 			}
-			homeserverMap, ok := versionMap[serverVersionInfo.Server.Version]
+			versionInfo, ok := serverInfo.Versions[serverVersionInfo.Server.Version]
 			if !ok {
-				homeserverMap = make(map[string]uint)
-				versionMap[serverVersionInfo.Server.Version] = homeserverMap
+				versionInfo = &VersionInfo{Homeservers: make(map[string]*HomeserverInfo)}
+				serverInfo.Versions[serverVersionInfo.Server.Version] = versionInfo
 			}
-			homeserverMap[hs] = members
+			homeserverInfo, ok := versionInfo.Homeservers[hs]
+			if !ok {
+				homeserverInfo = &HomeserverInfo{}
+				versionInfo.Homeservers[hs] = homeserverInfo
+			}
+			homeserverInfo.MemberCount = members
 		}
 	}
 
-	for roomID, roomIDValue := range roomMaxVersionInfos {
+	for roomID, roomInfo := range roomInfoTree {
 		fmt.Println("Room:")
 		fmt.Printf("  %s -> %d\n", givenRoomsByRoomID[roomID], membersByRoomID[roomID])
 
 		fmt.Println("Version Support:")
 
-		maxRoomVersionKeys := make([]string, 0, len(roomIDValue))
-		for key := range roomIDValue {
+		maxRoomVersionKeys := make([]string, 0, len(roomInfo.MaxRoomVersions))
+		for key := range roomInfo.MaxRoomVersions {
 			maxRoomVersionKeys = append(maxRoomVersionKeys, key)
 		}
 		slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
 		for _, maxRoomVersionKey := range maxRoomVersionKeys {
-			maxRoomVersionValue := roomIDValue[maxRoomVersionKey]
+			maxRoomVersionInfo := roomInfo.MaxRoomVersions[maxRoomVersionKey]
 
 			fmt.Printf("  %s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[MaxRoomVersionPath{roomID, maxRoomVersionKey}])
 
-			serverKeys := make([]string, 0, len(maxRoomVersionValue))
-			for key := range maxRoomVersionValue {
+			serverKeys := make([]string, 0, len(maxRoomVersionInfo.Servers))
+			for key := range maxRoomVersionInfo.Servers {
 				serverKeys = append(serverKeys, key)
 			}
 			sort.Strings(serverKeys)
 			for _, serverKey := range serverKeys {
-				serverValue := maxRoomVersionValue[serverKey]
+				serverInfo := maxRoomVersionInfo.Servers[serverKey]
 
 				fmt.Printf("    %s -> %d\n", serverKey, membersByServerPath[ServerPath{roomID, maxRoomVersionKey, serverKey}])
 
-				versionKeys := make([]string, 0, len(serverValue))
-				for key := range serverValue {
+				versionKeys := make([]string, 0, len(serverInfo.Versions))
+				for key := range serverInfo.Versions {
 					versionKeys = append(versionKeys, key)
 				}
 				slices.SortFunc(versionKeys, compareVersionStrings)
 				for _, versionKey := range versionKeys {
-					versionValue := serverValue[versionKey]
+					versionInfo := serverInfo.Versions[versionKey]
 
 					fmt.Printf("      %s -> %d\n", versionKey, membersByVersionPath[VersionPath{roomID, maxRoomVersionKey, serverKey, versionKey}])
 
 					if config.PrintHomeserverMemberCount {
-						homeserverKeys := make([]string, 0, len(versionValue))
-						for key := range versionValue {
+						homeserverKeys := make([]string, 0, len(versionInfo.Homeservers))
+						for key := range versionInfo.Homeservers {
 							homeserverKeys = append(homeserverKeys, key)
 						}
 						sort.Strings(homeserverKeys)
 						for _, homeserverKey := range homeserverKeys {
-							homeserverValue := versionValue[homeserverKey]
+							homeserverInfo := versionInfo.Homeservers[homeserverKey]
 
-							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverValue)
+							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverInfo.MemberCount)
 						}
 					}
 				}