fixed pointer issue

go.mod

@@ -3,7 +3,8 @@ module gitea.elara.ws/Hazel/music-kraken
 go 1.24.2
 
 require (
-	github.com/PuerkitoBio/goquery v1.10.3 // indirect
-	github.com/andybalholm/cascadia v1.3.3 // indirect
-	golang.org/x/net v0.45.0 // indirect
+	github.com/PuerkitoBio/goquery v1.10.3
+	golang.org/x/net v0.45.0
 )
+
+require github.com/andybalholm/cascadia v1.3.3 // indirect

internal/cli/shell.go

@@ -50,6 +50,9 @@ func printResults(musicObjects []data.MusicObject) {
 		if len(sources) > 0 {
 			for _, source := range sources {
 				results[i] += "\n\t- " + source.SourceType.Name + " " + string(source.ObjectType) + " " + source.Url
+				if source.AudioUrl != "" {
+					results[i] += "\n\t  " + source.AudioUrl
+				}
 			}
 		} else {
 			results[i] = color.StrikeThrough + results[i] + color.Reset
@@ -73,21 +76,29 @@ func (s musicObjectStore) currentMusicObjects() ([]data.MusicObject, error) {
 
 var indexSelectionPattern = regexp.MustCompile(`^[\d ,]+$`)
 
-func interpretCommand(command string, store musicObjectStore) (musicObjectStore, error) {
+func interpretCommand(command string, store musicObjectStore) (musicObjectStore, []error) {
 	// going back in history
 	if command == ".." {
 		if len(store) <= 1 {
-			return store, errors.New("can't go back")
+			return store, []error{errors.New("can't go back")}
 		}
 
-		return store[:len(store)-1], nil
+		return store[:len(store)-1], []error{}
+	}
+
+	forceDownload := false
+	if strings.HasPrefix(command, "d:") {
+		command, _ = strings.CutPrefix(command, "d:")
+		command = strings.TrimSpace(command)
+
+		forceDownload = true
 	}
 
 	// fetch special music object
 	if indexSelectionPattern.MatchString(command) {
 		currentMusicObjects, err := store.currentMusicObjects()
 		if err != nil {
-			return store, err
+			return store, []error{err}
 		}
 
 		var fetched data.MusicObject
@@ -96,14 +107,14 @@ func interpretCommand(command string, store musicObjectStore) (musicObjectStore,
 			index, _ := strconv.Atoi(strings.TrimSpace(stringIndex))
 
 			if index >= len(currentMusicObjects) || index < 0 {
-				return store, errors.New(command + " is out of bounds [0 <= " + strconv.Itoa(index) + " <= " + strconv.Itoa(len(currentMusicObjects)-1) + "]")
+				return store, []error{errors.New(command + " is out of bounds [0 <= " + strconv.Itoa(index) + " <= " + strconv.Itoa(len(currentMusicObjects)-1) + "]")}
 			}
 
 			current := currentMusicObjects[index]
 
 			newFetched, err := plugin.Fetch(current)
 			if err != nil {
-				return store, err
+				return store, []error{err}
 			}
 
 			if fetched == nil {
@@ -113,7 +124,13 @@ func interpretCommand(command string, store musicObjectStore) (musicObjectStore,
 			}
 		}
 
-		return append(store, fetched.Related()), nil
+		if forceDownload {
+			return store, plugin.Download(fetched)
+		} else {
+			return append(store, fetched.Related()), []error{}
+		}
+	} else if forceDownload {
+		return store, []error{errors.New("can only download indices not " + command)}
 	}
 
 	// search in every other case
@@ -123,30 +140,48 @@ func interpretCommand(command string, store musicObjectStore) (musicObjectStore,
 		fmt.Println()
 	}
 
-	return append(store, currentMusicObjects), nil
+	return append(store, currentMusicObjects), []error{}
 }
 
-func Shell() {
+func Shell(commandsList ...[]string) {
 	plugin.RegisterPlugin(&plugin.Musify{})
 
+	commands := []string{}
+	if len(commandsList) > 0 {
+		commands = commandsList[0]
+	}
+
 	fmt.Println("== MusicKraken Shell ==")
 	fmt.Println()
 
 	store := musicObjectStore{}
+	var err error = nil
 
 	for {
-		fmt.Print("> ")
+		var command string
 
-		reader := bufio.NewReader(os.Stdin)
-		command, err := reader.ReadString('\n')
-		if err != nil {
-			log.Fatal(err)
+		if len(commands) <= 0 {
+			fmt.Print("> ")
+
+			reader := bufio.NewReader(os.Stdin)
+			command, err = reader.ReadString('\n')
+			if err != nil {
+				log.Fatal(err)
+			}
+		} else {
+			command = commands[0]
+			commands = commands[1:]
+
+			fmt.Println("> " + command)
 		}
 
-		store, err = interpretCommand(strings.TrimSpace(command), store)
-		if err != nil {
+		var errList []error
+		store, errList = interpretCommand(strings.TrimSpace(command), store)
+		if len(errList) > 0 {
 			fmt.Println()
-			fmt.Println(color.Yellow + err.Error() + color.Reset)
+			for _, err := range errList {
+				fmt.Println(color.Yellow + err.Error() + color.Reset)
+			}
 			fmt.Println()
 		}
 

internal/common/strings.go

@@ -21,3 +21,104 @@ func ZeroPad(num int, length int) string {
 	}
 	return strings.Repeat("0", length-len(str)) + str
 }
+
+func IsNumeric(num string) bool {
+	for _, c := range num {
+		if c < '0' || c > '9' {
+			return false
+		}
+	}
+	return true
+}
+
+var commonTitleSuffix = []string{"(official video)"}
+
+const openBrackets = "(["
+const closeBrackets = ")]"
+
+var forbiddenSubstringInBrackets = []string{"official", "video", "audio", "lyrics", "prod", "remix", "ft", "feat", "ft.", "feat."}
+
+func CleanSongTitle(title string, artistName string) string {
+	/*
+		# remove brackets and their content if they contain disallowed substrings
+		for open_bracket, close_bracket in zip(OPEN_BRACKETS, CLOSE_BRACKETS):
+		    if open_bracket not in raw_song_title or close_bracket not in raw_song_title:
+		        continue
+
+		    start = 0
+
+		    while True:
+		        try:
+		            open_bracket_index = raw_song_title.index(open_bracket, start)
+		        except ValueError:
+		            break
+		        try:
+		            close_bracket_index = raw_song_title.index(close_bracket, open_bracket_index + 1)
+		        except ValueError:
+		            break
+
+		        substring = raw_song_title[open_bracket_index + 1:close_bracket_index]
+		        if any(disallowed_substring in substring.lower() for disallowed_substring in DISALLOWED_SUBSTRING_IN_BRACKETS):
+		            raw_song_title = raw_song_title[:open_bracket_index] + raw_song_title[close_bracket_index + 1:]
+		        else:
+		            start = close_bracket_index + 1
+
+		# everything that requires the artist name
+		if artist_name is not None:
+		    artist_name = artist_name.strip()
+
+		    # Remove artist from the start of the title
+		    if raw_song_title.lower().startswith(artist_name.lower()):
+
+		        possible_new_name = raw_song_title[len(artist_name):].strip()
+
+		        for char in ("-", "–", ":", "|"):
+		            if possible_new_name.startswith(char):
+		                raw_song_title = possible_new_name[1:].strip()
+		                break
+
+		return raw_song_title.strip()
+
+	*/
+
+	title = strings.TrimSpace(title)
+
+	for _, d := range commonTitleSuffix {
+		if strings.HasSuffix(strings.ToLower(title), d) {
+			title = strings.TrimSpace(title[:len(d)-1])
+		}
+	}
+
+	for b, open := range openBrackets {
+		close := closeBrackets[b]
+
+		s := -1
+		e := -1
+
+		for i, c := range title {
+			if c == open {
+				s = i
+			} else if c == rune(close) {
+				e = i
+			}
+		}
+
+		remove := false
+		if s > -1 {
+			substring := title[s:e]
+
+			for _, f := range forbiddenSubstringInBrackets {
+				if strings.Contains(substring, f) {
+					remove = true
+					break
+				}
+			}
+		}
+
+		if remove {
+			title = title[:s] + title[e:]
+		}
+	}
+
+	return title
+}

internal/data/source.go

@@ -19,7 +19,9 @@ const AlbumSource = ObjectType("album")
 const ArtistSource = ObjectType("artist")
 
 type Source struct {
-	Url        string
+	Url      string
+	AudioUrl string // will only be used when ObjectType = SongSource
+
 	SourceType *SourceType
 	ObjectType ObjectType
 }
@@ -38,6 +40,9 @@ func dedupeSources(inputSources []Source) []Source {
 			if source.SourceType != nil {
 				deduped[mergeWithIndex].SourceType = source.SourceType
 			}
+			if source.AudioUrl != "" {
+				deduped[mergeWithIndex].AudioUrl = source.AudioUrl
+			}
 
 		} else {
 			// just appending

internal/plugin/interface.go

@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"errors"
+	"fmt"
 	"regexp"
 
 	"gitea.elara.ws/Hazel/music-kraken/internal/common"
@@ -163,7 +164,7 @@ func Fetch(musicObject data.MusicObject) (data.MusicObject, error) {
 		musicObject = musicObject.Merge(newMusicObject)
 	}
 
-	return musicObject, nil
+	return musicObject.Compile(), nil
 }
 
 type SearchConfig struct {
@@ -189,3 +190,93 @@ func Search(search string, config SearchConfig) ([]data.MusicObject, error) {
 
 	return res, nil
 }
+
+type downloadState struct {
+	artist *data.Artist
+	album  *data.Album
+	song   *data.Song
+}
+
+var variousArtist = data.Artist{
+	Name: "VariousArtist",
+}.Compile().(data.Artist)
+
+var variousAlbum = data.Album{
+	Name: "VariousAlbum",
+}.Compile().(data.Album)
+
+func downloadSong(song data.Song, state downloadState) error {
+	fmt.Println("downloading: " + song.Name)
+	return nil
+}
+
+func Download(musicObject data.MusicObject, statesInput ...downloadState) []error {
+	state := downloadState{}
+	if len(statesInput) > 0 {
+		state = statesInput[0]
+	}
+
+	musicObject, err := Fetch(musicObject)
+	if err != nil {
+		return []error{err}
+	}
+
+	if song, ok := musicObject.(data.Song); ok {
+		state.song = &song
+
+		if state.artist == nil {
+			if len(song.Artists) > 0 {
+				state.artist = &song.Artists[0]
+			} else {
+				state.artist = &variousArtist
+			}
+		}
+
+		if state.album == nil {
+			if song.Album.Name != "" {
+				state.album = &song.Album
+			} else {
+				state.album = &variousAlbum
+			}
+		}
+
+		err := downloadSong(song, state)
+		if err == nil {
+			return []error{}
+		} else {
+			return []error{err}
+		}
+	}
+
+	if album, ok := musicObject.(data.Album); ok {
+		state.album = &album
+
+		if state.artist == nil {
+			if len(album.Artists) > 0 {
+				state.artist = &album.Artists[0]
+			} else {
+				state.artist = &variousArtist
+			}
+		}
+
+		errList := []error{}
+		for _, song := range album.Songs {
+			errList = append(errList, Download(song, state)...)
+		}
+		return errList
+	}
+
+	if artist, ok := musicObject.(data.Artist); ok {
+		state.artist = &artist
+
+		errList := []error{}
+		for _, album := range artist.Albums {
+			errList = append(errList, Download(album, state)...)
+		}
+		return errList
+	}
+
+	return []error{
+		errors.New("music object not recognized"),
+	}
+}

internal/plugin/musify.go

@@ -2,6 +2,8 @@ package plugin
 
 import (
 	"errors"
+	"fmt"
+	"net/url"
 	"regexp"
 	"strings"
 
@@ -278,6 +280,39 @@ func (m *Musify) Search(query common.Query) ([]data.MusicObject, error) {
 	return musicObjects, nil
 }
 
+type parsedSongUrl struct {
+	id   string
+	name string
+	url  string
+}
+
+func newParsedSongUrl(rawUrl string) (parsedSongUrl, error) {
+	res := parsedSongUrl{
+		url: rawUrl,
+	}
+
+	parsed, err := url.Parse(rawUrl)
+	if err != nil {
+		return res, err
+	}
+
+	dirs := strings.Split(parsed.Path, "/")
+	correctPart := dirs[len(dirs)-1]
+	split := strings.Split(correctPart, "-")
+	if len(split) < 2 {
+		return res, errors.New("last part of path has to consist of at least one - " + correctPart)
+	}
+
+	res.id = strings.TrimSpace(split[len(split)-1])
+	res.name = strings.Join(split[:len(split)-1], "-")
+
+	if !common.IsNumeric(res.id) {
+		return res, errors.New("last elem (id) has to be numeric " + res.id)
+	}
+
+	return res, nil
+}
+
 func (m *Musify) FetchSong(source data.Source) (data.Song, error) {
 	song := data.Song{
 		Sources: []data.Source{
@@ -296,14 +331,19 @@ func (m *Musify) FetchSong(source data.Source) (data.Song, error) {
 	}
 
 	// Download URL
-	/*
-		doc.Find("a[itemprop='audio']").Each(func(i int, anchor *goquery.Selection) {
-			href, exists := anchor.Attr("href")
-			if exists {
-				source.AudioURL = p.host + href
+	doc.Find("a[itemprop='audio']").Each(func(i int, anchor *goquery.Selection) {
+		if href, _ := anchor.Attr("href"); true {
+			// will be the source first added at the begining
+			song.Sources[0].AudioUrl = musifyHost + href
+		} else {
+			// http://musify.club/track/dl/7141298/crystal-f-sekundenschlaf.mp3
+			parsed, err := newParsedSongUrl(song.Sources[0].Url)
+			if err != nil {
+				return
 			}
-		})
-	*/
+			song.Sources[0].AudioUrl = "http://musify.club/track/dl/" + parsed.id + "/" + parsed.name + ".mp3"
+		}
+	})
 
 	// Song detail
 	var listElement *goquery.Selection
@@ -616,8 +656,288 @@ func (m Musify) FetchAlbum(source data.Source) (data.Album, error) {
 	return album, nil
 }
 
-func (m Musify) FetchArtist(source data.Source) (data.Artist, error) {
-	return data.Artist{
-		Name: extractName(source.Url),
-	}, nil
+type parsedArtistUrl struct {
+	id   string
+	name string
+	url  string
+}
+
+func newParsedArtistUrl(rawUrl string) (parsedArtistUrl, error) {
+	res := parsedArtistUrl{
+		url: rawUrl,
+	}
+
+	parsed, err := url.Parse(rawUrl)
+	if err != nil {
+		return res, err
+	}
+
+	dirs := strings.Split(parsed.Path, "/")
+	correctPart := dirs[len(dirs)-1]
+	split := strings.Split(correctPart, "-")
+	if len(split) < 2 {
+		return res, errors.New("last part of path has to consist of at least one - " + correctPart)
+	}
+
+	res.id = split[len(split)-1]
+	res.name = strings.Join(split[:len(split)-1], "-")
+
+	if !common.IsNumeric(res.id) {
+		return res, errors.New("last elem (id) has to be numeric " + res.id)
+	}
+
+	return res, nil
+}
+
+func (m *Musify) fetchInitialArtist(parsed parsedArtistUrl, artist data.Artist) (data.Artist, error) {
+	endpoint := fmt.Sprintf("https://musify.club/artist/%s?_pjax=#bodyContent", parsed.name)
+	resp, err := m.session.Get(endpoint)
+	if err != nil {
+		return artist, err
+	}
+
+	doc, err := scraper.GetHtml(resp)
+	if err != nil {
+		return artist, err
+	}
+
+	// Breadcrumbs
+	breadcrumbs := doc.Find("ol.breadcrumb")
+	if breadcrumbs.Length() > 0 {
+		breadcrumbList := breadcrumbs.Find("li.breadcrumb-item")
+		if breadcrumbList.Length() == 3 {
+			artist.Name = strings.TrimSpace(breadcrumbList.Eq(2).Text())
+		} else {
+			return artist, errors.New("breadcrumb layout on artist page changed")
+		}
+	}
+
+	// Nav tabs for songs link
+	navTabs := doc.Find("ul.nav-tabs")
+	if navTabs.Length() > 0 {
+		navTabs.Find("li.nav-item").Each(func(i int, listItem *goquery.Selection) {
+			if strings.HasPrefix(strings.TrimSpace(listItem.Text()), "песни") {
+				// "песни" translates to "songs"
+				anchor := listItem.Find("a")
+				if href, exists := anchor.Attr("href"); exists {
+					artist.Sources = append(artist.Sources, data.Source{
+						Url: musifyHost + href,
+					})
+				}
+			}
+
+		})
+	}
+
+	// Content title
+	contentTitle := doc.Find("header.content__title")
+	if contentTitle.Length() > 0 {
+		h1Name := contentTitle.Find("h1")
+		if h1Name.Length() > 0 {
+			artist.Name = strings.TrimSpace(h1Name.Text())
+		}
+	}
+
+	// Country and additional sources from icon list
+	iconList := doc.Find("ul.icon-list")
+	if iconList.Length() > 0 {
+		// Country flag - simplified version
+		countryFlag := iconList.Find("i.flag-icon")
+		if countryFlag.Length() > 0 {
+			// Extract country code from class names
+			classes, _ := countryFlag.Attr("class")
+			classList := strings.Fields(classes)
+			for _, class := range classList {
+				if class != "flag-icon" && class != "shadow" && len(class) == 2 {
+					// This would be where you'd use a country lookup library
+					// artist.Country = getCountryFromCode(class)
+					break
+				}
+			}
+		}
+
+		// Additional sources
+		iconList.Find("a.link").Each(func(i int, additionalSource *goquery.Selection) {
+			if href, exists := additionalSource.Attr("href"); exists {
+				// Simplified source matching - you'd implement your Source.matchUrl equivalent
+				artist.Sources = append(artist.Sources, data.Source{Url: href})
+			}
+		})
+	}
+
+	/*
+		// Notes
+		noteSection := doc.Find("#text-main")
+		if noteSection.Length() > 0 {
+			html, _ := noteSection.Html()
+			// artist.Notes = FormattedText{HTML: html} - if you have this field
+		}
+
+		// Artist artwork
+		doc.Find("img.artist-img").Each(func(i int, img *goquery.Selection) {
+			src, exists := img.Attr("data-src")
+			if !exists {
+				src, _ = img.Attr("src")
+			}
+			if src != "" {
+				// artist.Artwork = append(artist.Artwork, Artwork{Url: src})
+			}
+		})
+	*/
+
+	return artist, nil
+}
+
+func (m Musify) parseAlbumCard(albumCard *goquery.Selection, artistName string) (data.Album, error) {
+	album := data.Album{
+		Sources: []data.Source{},
+		Artists: []data.Artist{},
+		Songs:   []data.Song{},
+	}
+
+	/*
+		// Album type from data attribute
+		if albumTypeID, exists := albumCard.Attr("data-type"); exists {
+			if parsedType, err := strconv.Atoi(albumTypeID); err == nil {
+				// album.Type = getAlbumTypeFromID(parsedType) - implement your mapping
+				if parsedType == 5 {
+					// album.Status = AlbumStatusBootleg
+				}
+			}
+		}
+	*/
+
+	// Parse release anchor
+	parseReleaseAnchor := func(anchor *goquery.Selection, textIsName bool) {
+		if anchor == nil {
+			return
+		}
+
+		if href, exists := anchor.Attr("href"); exists {
+			album.Sources = append(album.Sources, data.Source{
+				Url:        musifyHost + href,
+				ObjectType: data.AlbumSource,
+				SourceType: &m.sourceType,
+			})
+		}
+
+		if textIsName {
+			album.Name = common.CleanSongTitle(strings.TrimSpace(anchor.Text()), artistName)
+		}
+	}
+
+	// Main thumbnail anchor
+	anchorList := albumCard.Find("a")
+	if anchorList.Length() > 0 {
+		mainAnchor := anchorList.First()
+		parseReleaseAnchor(mainAnchor, false)
+
+		/*
+			// Thumbnail image
+			thumbnail := mainAnchor.Find("img")
+			if thumbnail.Length() > 0 {
+				if alt, exists := thumbnail.Attr("alt"); exists {
+					album.Name = common.CleanSongTitle(alt, artistName)
+				}
+
+				// Image URL could be stored if needed
+				// if src, exists := thumbnail.Attr("src"); exists { ... }
+			}
+		*/
+	} else {
+		return album, errors.New("the card has no thumbnail or url")
+	}
+
+	// Card body
+	cardBody := albumCard.Find("div.card-body")
+	if cardBody.Length() > 0 {
+		parseReleaseAnchor(cardBody.Find("a"), true)
+	}
+
+	/*
+			// Parse date from card footer
+			parseSmallDate := func(small *goquery.Selection) {
+				italic := small.Find("i")
+				if italic.Length() == 0 {
+					return
+				}
+
+				if title, exists := italic.Attr("title"); exists && title == "Добавлено" {
+					rawTime := strings.TrimSpace(small.Text())
+					// Parse date from "13.11.2021" format
+					// album.Date = parseDate(rawTime, "02.01.2006")
+				}
+			}
+
+		// Card footers
+		cardFooters := albumCard.Find("div.card-footer")
+		if cardFooters.Length() == 3 {
+			lastFooter := cardFooters.Last()
+			lastFooter.Find("small").Each(func(i int, small *goquery.Selection) {
+				parseSmallDate(small)
+			})
+		} else {
+			m.logger.Debug(fmt.Sprintf("expected 3 card footers, got %d", cardFooters.Length()))
+		}
+	*/
+
+	return album, nil
+}
+
+func (m *Musify) fetchArtistDiscography(url parsedArtistUrl, artistName string, albumTypeBlacklist []string) ([]data.Album, error) {
+	albumList := []data.Album{}
+
+	endpoint := "https://musify.club/discography/filteralbums"
+
+	// POST request with form data
+	formData := map[string]string{
+		"ArtistID":              url.id,
+		"SortOrder.Property":    "dateCreated",
+		"SortOrder.IsAscending": "false",
+		"X-Requested-With":      "XMLHttpRequest",
+	}
+	resp, err := m.session.PostForm(endpoint, formData, map[string]string{"X-Requested-With": "XMLHttpRequest"})
+	if err != nil {
+		return albumList, err
+	}
+
+	doc, err := scraper.GetHtml(resp)
+	if err != nil {
+		return albumList, err
+	}
+
+	doc.Find("div.card").Each(func(i int, card *goquery.Selection) {
+		album, err := m.parseAlbumCard(card, artistName)
+
+		if err != nil {
+			fmt.Println(err)
+		}
+
+		albumList = append(albumList, album)
+	})
+
+	return albumList, nil
+}
+
+func (m *Musify) FetchArtist(source data.Source) (data.Artist, error) {
+	res := data.Artist{
+		Name: extractName(source.Url),
+	}
+	parsed, err := newParsedArtistUrl(source.Url)
+	if err != nil {
+		return res, err
+	}
+
+	res, err = m.fetchInitialArtist(parsed, res)
+	if err != nil {
+		return res, err
+	}
+
+	albumList, err := m.fetchArtistDiscography(parsed, res.Name, []string{})
+	if err != nil {
+		return res, err
+	}
+	res.Albums = append(res.Albums, albumList...)
+
+	return res, nil
 }

internal/scraper/session.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"net/http/cookiejar"
 	"net/url"
+	"strings"
 	"time"
 
 	"golang.org/x/net/publicsuffix"
@@ -118,6 +119,32 @@ func (s *Session) PostMultipartForm(url string, data map[string]string, headers
 	return s.client.Do(req)
 }
 
+func (s *Session) PostForm(rawUrl string, data map[string]string, headers ...map[string]string) (*http.Response, error) {
+	fullURL := s.buildURL(rawUrl)
+
+	// Prepare form data
+	formData := url.Values{}
+	for k, v := range data {
+		formData.Add(k, v)
+	}
+	req, err := http.NewRequest("POST", fullURL, strings.NewReader(formData.Encode()))
+	if err != nil {
+		return nil, err
+	}
+
+	s.setDefaultHeaders(req)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	// Add any additional headers provided
+	if len(headers) > 0 {
+		for key, value := range headers[0] {
+			req.Header.Set(key, value)
+		}
+	}
+
+	return s.client.Do(req)
+}
+
 // PostJSON performs a POST request with JSON data
 func (s *Session) PostJSON(url string, data interface{}, headers ...map[string]string) (*http.Response, error) {
 	fullURL := s.buildURL(url)

main.go

@@ -5,5 +5,8 @@ import (
 )
 
 func main() {
-	cli.Shell()
+	cli.Shell([]string{
+		"#a Crystal F",
+		"d: 0",
+	})
 }