christian @ bigiron ➜  cd $MUSIC/Dornenreich/Flammentriebe
christian @ bigiron ➜  Flammentriebe  id3v2 -l 01\ Flammenmensch.mp3
id3v1 tag info for 01 Flammenmensch.mp3:
Title  : Flammenmensch                   Artist: Dornenreich
Album  : Flammentriebe                   Year: 2011, Genre: Black Metal (138)
Comment:                                 Track: 1
id3v2 tag info for 01 Flammenmensch.mp3:
TIT2 (Title/songname/content description): Flammenmensch
TPE1 (Lead performer(s)/Soloist(s)): Dornenreich
TRCK (Track number/Position in set): 1/8
TALB (Album/Movie/Show title): Flammentriebe
TPOS (Part of a set): 1/1
TCON (Content type): Black Metal (138)
TMED (Media type): CD

mkdir -p "$DEV_ENV/GooglePlayMusic/Takeout/Google Play Music/"
cp -r "$PROD_ENV/GooglePlayMusic/Takeout/Google Play Music/Radio\ Stations" "$DEV_ENV/GooglePlayMusic/Takeout/Google Play Music/"
cp -r "$PROD_ENV/GooglePlayMusic/Takeout/Google Play Music/Playlists" "$DEV_ENV/GooglePlayMusic/Takeout/Google Play Music/"
find "/mnt/6TB/Downloads/GooglePlayMusic/Takeout/Google Play Music/Tracks/" -maxdepth 1 -type f | shuf | head -1000 > /tmp/sample.txt
while read l; do cp "${l}" "/mnt/1TB/Dev/GooglePlayMusic/Takeout/Google Play Music/Tracks/"; done < /tmp/sample.txt

#!/bin/bash
# Exit on error
set -e
POSITIONAL=()
while [[ $# > 0 ]]; do
    case "$1" in
        -b|--base-dir)
        BASE_DIR="${2}"
        shift 2
        ;;
        -t|--target-dir)
        TARGET_DIR="${2}"
        shift 2
        ;;
        *)
        POSITIONAL+=("$1")
        shift
        ;;
    esac
done
set -- "${POSITIONAL[@]}"
# Check args
if [[ -z "${BASE_DIR}" || -z "${TARGET_DIR}" ]]; then
    echo "Usage: organize.sh --base-dir \$PATH_TO_EXPORT --target_dir \$PATH_TO_OUTPUT"
    exit 1
fi
# Set base folders
TRACK_FOLDER="${BASE_DIR}/Tracks"
PLAYLISTS_FOLDER="${BASE_DIR}/Playlists"
RADIO_FOLDER="${BASE_DIR}/Radio Stations"
# Check folder
if [[ ! -d "${TRACK_FOLDER}" || ! -d "${PLAYLISTS_FOLDER}" || ! -d "${RADIO_FOLDER}" ]]; then
    echo "--base-dir must point to the folder containing /Tracks, /Playlists, and /Radio\ Stations"
    exit 1
fi
# Define targets
echo "Creating target dirs in $TARGET_DIR..."
mkdir -p "${TARGET_DIR}"
CSV_TARGET="${TARGET_DIR}/csv/"
MP3_TARGET="${TARGET_DIR}/mp3/"
PLAYLIST_TARGET="${TARGET_DIR}/playlists/"
RADIO_TARGET="${TARGET_DIR}/radios/"
# Create structure for CSVs and MP3s
mkdir -p "${CSV_TARGET}"
mkdir -p "${MP3_TARGET}"
mkdir -p "${PLAYLIST_TARGET}"
mkdir -p "${RADIO_TARGET}"
# Copy flat files files
echo "Copying files from $TRACK_FOLDER..."
find "${TRACK_FOLDER}" -type f -iname "*.csv" -exec cp -- "{}" "${CSV_TARGET}" \;
find "${TRACK_FOLDER}" -type f -iname "*.mp3" -exec cp -- "{}" "${MP3_TARGET}" \;
# Playlists need to be concatenated
echo "Copying files from $PLAYLISTS_FOLDER..."
find "${PLAYLISTS_FOLDER}" -type f -mmin +1 -print0 | while IFS="" read -r -d "" f; do
    # Ignore summaries
    if [[ ! -z $(echo "${f}" | grep "Tracks/" ) ]]; then
        # Group
        playlistName="$(basename "$(dirname "$(dirname "${f}")")")"
        targetCsv="${PLAYLIST_TARGET}/$playlistName.csv"
        touch "${targetCsv}"
        echo "Working on playlist $playlistName to $targetCsv"
        # Add header
        if [[ -z $(cat "${targetCsv}" | grep "Title,Album,Artist") ]]; then
            echo "Title,Album,Artist,Duration (ms),Rating,Play Count,Removed,Playlist Index" > "${targetCsv}"
        fi
        echo "$(tail -n +2 "${f}")" >> "${targetCsv}"
    fi
done
# Just flat file copy
echo "Copying files from $RADIO_TARGET..."
find "${RADIO_FOLDER}" -type f -exec cp -- "{}" "${RADIO_TARGET}" \;

christian @ bigiron ➜  ./organize.sh --base-dir "$DEV_ENV" --target-dir ./clean/
christian @ bigiron ➜  clean  tree -d .
.
├── csv
├── mp3
├── playlists
└── radios
christian @ bigiron ➜  clean  du -h --max-depth=1 .
2.1M  ./csv
4.7G  ./mp3
5.1M  ./playlists
4.0K  ./radios
4.7G

import pandas as pd
import glob
import argparse
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-i', '--in_dir', type=str, required=True, help='Input directory')
    args = parser.parse_args()
    df = pd.concat((pd.read_csv(f) for f in glob.glob(args.in_dir)))
    print(f'Schema for %s is:', in_dir)
    print(df.info(show_counts=True))

<class 'pandas.core.frame.DataFrame'>
Int64Index: 1283 entries, 0 to 0
Data columns (total 8 columns):
 #   Column          Non-Null Count  Dtype
---  ------          --------------  -----
 0   Title           1283 non-null   object
 1   Album           1283 non-null   object
 2   Artist          1283 non-null   object
 3   Duration (ms)   1283 non-null   int64
 4   Rating          1283 non-null   int64
 5   Play Count      1283 non-null   int64
 6   Removed         0 non-null      float64
 7   Playlist Index  1283 non-null   int64
dtypes: float64(1), int64(4), object(3)
memory usage: 90.2+ KB

CREATE DATABASE IF NOT EXISTS `googleplay_raw`;
CREATE OR REPLACE TABLE `googleplay_raw`.`song` (
    `title`          TEXT,
    `album`          TEXT,
    `artist`      TEXT,
    `duration_ms`  INTEGER,
    `rating`      INTEGER,
    `play_count`  INTEGER,
    `removed`      FLOAT,
    `file_name`     TEXT
);

#!/bin/bash
# Exit on error
set -e
POSITIONAL=()
while [[ $# > 0 ]]; do
    case "$1" in
        -b|--base-dir)
        BASE_DIR="${2}"
        shift 2
        ;;
        *)
        POSITIONAL+=("$1")
        shift
        ;;
    esac
done
set -- "${POSITIONAL[@]}"
# Check args
if [[ -z "${BASE_DIR}" ]]; then
    echo "Usage: add_filename_to_csv.sh --base-dir \$PATH_TO_EXPORT"
    exit 1
fi
find "${BASE_DIR}" -type f -name "*.csv" -print0 | while IFS= read -r -d '' f; do
    echo "" > /tmp/out.csv
    bname=$(basename "${f}")
    echo "Adding $bname to $f"
    ix=0
    while read l; do
        if [[ $ix -eq 0 ]]; then
            echo "${l},file_name" >> /tmp/out.csv
        else
            echo "${l},${bname}" >> /tmp/out.csv
        fi
        ix=$(($ix + 1))
    done < "$f"
    IFS=$OLDIFS
    if [[ $ix -ne 0 ]]; then
        cat "/tmp/out.csv" > "${f}"
    else
        echo "File $f is empty"
    fi
done

cat clean/csv/Loki\ God\ of\ Fire.csv
Title,Album,Artist,Duration (ms),Rating,Play Count,Removed
"Loki God of Fire","Gods of War","Manowar","230016","0","1",""

Title,Album,Artist,Duration (ms),Rating,Play Count,Removed,file_name
"Loki God of Fire","Gods of War","Manowar","230016","0","1","","Loki God of Fire.csv"

import (
//..
  "github.com/apache/beam/sdks/go/pkg/beam"
// ..
)
type Song struct {
  Title       string `column:"title"`
  Album       string `column:"album"`
  Artist      string `column:"artist"`
  // ..
}
func (s Song) getCols() []string {
  return []string{"title", "album", "artist", "duration_ms", "rating", "play_count", "removed", "file_name"}
}
func (f *Song) ProcessElement(w string, emit func(Song)) {
  data := strings.Split(w, ",")
  //..
  // Filter non-null fields
  if data[0] != "" {
    fmt.Printf("Song: %v\n", s)
    emit(*s)
  }
}
func main() {
//..
  beam.Init()
  p := beam.NewPipeline()
  s := p.Root()
  // Build pipeline
  lines := textio.Read(s, *trackCsvDir)
  songs := beam.ParDo(s, &Song{}, lines)
  // Write to DB
  databaseio.Write(s, "mysql", conStr, "song", Song{}.getCols(), songs)
  // Run until we find errors
  if err := beamx.Run(context.Background(), p); err != nil {
    log.Fatalf("Failed to execute job: %v", err)
  }
}

8: ParDo[beam.createFn] Out:[7]
        caused by:
        creating row mapper
failed to matched a main.Song field for SQL column: title
exit status 1

type Song struct {
  Title       string `column:"title"`
  Album       string `column:"album"`
  Artist      string `column:"artist"`
  Duration_ms int    `column:"duration_ms"`
  Rating      int    `column:"rating"`
  Play_count  int    `column:"play_count"`
  Removed     int    `column:"removed"`
}

package main
import (
  "context"
  "flag"
  "fmt"
  "log"
  "strconv"
  "github.com/apache/beam/sdks/go/pkg/beam"
  "github.com/apache/beam/sdks/go/pkg/beam/io/databaseio"
  "github.com/apache/beam/sdks/go/pkg/beam/io/textio"
  "github.com/apache/beam/sdks/go/pkg/beam/x/beamx"
  _ "github.com/go-sql-driver/mysql"
)
var (
  trackCsvDir      = flag.String("track_csv_dir", "", "Directory containing all track CSVs")
  playlistsCsvDir  = flag.String("playlist_csv_dir", "", "Directory containing all playlist CSVs")
  radioCsvDir      = flag.String("radio_csv_dir", "", "Directory containing all radio CSVs")
  databaseHost     = flag.String("database_host", "localhost", "Database host")
  databaseUser     = flag.String("database_user", "", "Database user")
  databasePassword = flag.String("database_password", "", "Database password")
  database         = flag.String("database", "googleplay_raw", "Database name")
)
type Playlist struct {
  Title         string `column:"title"`
  Album         string `column:"album"`
  Artist        string `column:"artist"`
  Duration_ms   int    `column:"duration_ms"`
  Rating        int    `column:"rating"`
  Play_count    int    `column:"play_count"`
  Removed       bool   `column:"removed"`
  PlaylistIndex int    `column:"playlist_ix"`
}
func (s Playlist) getCols() []string {
  return []string{"title", "album", "artist", "duration_ms", "rating", "play_count", "removed", "playlist_ix"}
}
func (f *Playlist) ProcessElement(w string, emit func(Playlist)) {
  data, err := PrepCsv(w)
  if err != nil {
    return
  }
  duration_ms, _ := strconv.Atoi(GetOrDefault(data, 3))
  rating, _ := strconv.Atoi(GetOrDefault(data, 4))
  playCount, _ := strconv.Atoi(GetOrDefault(data, 5))
  playlist_ix, _ := strconv.Atoi(GetOrDefault(data, 7))
  s := &Playlist{
    Title:         GetOrDefault(data, 0),
    Album:         GetOrDefault(data, 1),
    Artist:        GetOrDefault(data, 2),
    Duration_ms:   duration_ms,
    Rating:        rating,
    Play_count:    playCount,
    Removed:       ParseRemoved(data, 6),
    PlaylistIndex: playlist_ix,
  }
  fmt.Printf("Playlist: %v\n", s)
  emit(*s)
}
type Song struct {
  Title       string `column:"title"`
  Album       string `column:"album"`
  Artist      string `column:"artist"`
  Duration_ms int    `column:"duration_ms"`
  Rating      int    `column:"rating"`
  Play_count  int    `column:"play_count"`
  Removed     bool   `column:"removed"`
  FileName    string `column:"file_name"`
}
func (s Song) getCols() []string {
  return []string{"title", "album", "artist", "duration_ms", "rating", "play_count", "removed", "file_name"}
}
func (f *Song) ProcessElement(w string, emit func(Song)) {
  data, err := PrepCsv(w)
  if err != nil {
    return
  }
  duration_ms, _ := strconv.Atoi(GetOrDefault(data, 3))
  rating, _ := strconv.Atoi(GetOrDefault(data, 4))
  playCount, _ := strconv.Atoi(GetOrDefault(data, 5))
  s := &Song{
    Title:       GetOrDefault(data, 0),
    Album:       GetOrDefault(data, 1),
    Artist:      GetOrDefault(data, 2),
    Duration_ms: duration_ms,
    Rating:      rating,
    Play_count:  playCount,
    Removed:     ParseRemoved(data, 6),
    FileName:    GetOrDefault(data, 7),
  }
  fmt.Printf("Song: %v\n", s)
  emit(*s)
}
type Radio struct {
  Title                   string `column:"title"`
  Artist                  string `column:"artist"`
  Description             string `column:"description"`
  Removed                 bool   `column:"removed"`
  Similar_stations        string `column:"similar_stations"`
  Artists_on_this_station string `column:"artists_on_this_station"`
}
func (s Radio) getCols() []string {
  return []string{"title", "artist", "description", "removed", "similar_stations", "artists_on_this_station"}
}
func (f *Radio) ProcessElement(w string, emit func(Radio)) {
  data, err := PrepCsv(w)
  if err != nil {
    return
  }
  s := &Radio{
    Title:                   GetOrDefault(data, 0),
    Artist:                  GetOrDefault(data, 1),
    Description:             GetOrDefault(data, 2),
    Removed:                 ParseRemoved(data, 3),
    Similar_stations:        GetOrDefault(data, 4),
    Artists_on_this_station: GetOrDefault(data, 5),
  }
  fmt.Printf("Radio: %v\n", s)
  emit(*s)
}
func process(s beam.Scope, t interface{}, cols []string, inDir, dsn, table string) {
  // Read
  lines := textio.Read(s, inDir)
  data := beam.ParDo(s, t, lines)
  // Write to DB
  databaseio.Write(s, "mysql", dsn, table, cols, data)
}
func main() {
  // Check flags
  flag.Parse()
  if *trackCsvDir == "" || *playlistsCsvDir == "" || *radioCsvDir == "" || *databasePassword == "" {
    log.Fatalf("Usage: index_match --track-csv_dir=$TRACK_DIR --playlist_csv_dir=$PLAYLIST_DIR --radio_csv_dir=$RADIO_DIR--database_password=$PW [--database_host=$HOST --database_user=$USER]")
  }
  dsn := fmt.Sprintf("%v:%v@tcp(%v:3306)/%v", *databaseUser, *databasePassword, *databaseHost, *database)
  fmt.Printf("dsn: %v\n", dsn)
  fmt.Printf("cols: %v\n", Song{}.getCols())
  // Initialize Beam
  beam.Init()
  p := beam.NewPipeline()
  s := p.Root()
  // Songs
  process(s, &Song{}, Song{}.getCols(), *trackCsvDir, dsn, "song")
  // Radio
  process(s, &Radio{}, Radio{}.getCols(), *radioCsvDir, dsn, "radio")
  // Playlists
  process(s, &Playlist{}, Playlist{}.getCols(), *playlistsCsvDir, dsn, "playlists")
  // Run until we find errors
  if err := beamx.Run(context.Background(), p); err != nil {
    log.Fatalf("Failed to execute job: %v", err)
  }
}

export GOLANG_PROTOBUF_REGISTRATION_CONFLICT=ignore
go get github.com/go-sql-driver/mysql
go get -u github.com/apache/beam/sdks/go/...
PW=password
DB_USER=takeout
DB_HOST=bigirion.local
go run 03-beam-csv-to-sql.go \
  --track_csv_dir="$(pwd)/test_data/clean/csv/*.csv" \
  --playlist_csv_dir="$(pwd)/test_data/clean/playlists/*.csv" \
  --radio_csv_dir="$(pwd)/test_data/clean/radios/*.csv" \
  --database_host=$DB_HOST \
  --database_user=$DB_USER \
  --database_password="${PW}"

find $(pwd)/clean/mp3 -type f -name "*.mp3" > all_mp3.txt

type Id3Data struct {
  Artist    string `column:"artist"`   // TPE1
  Title     string `column:"title"`    // TIT2
  Album     string `column:"album"`    // TALB
  Year      int    `column:"year"`     // TYER
  Genre     string `column:"genre"`    // TCON
  TrackPos  int    `column:"trackPos"` // TRCK
  TrackMax  int    `column:"maxTrackPos"`
  PartOfSet string `column:"partOfSet"` // TPOS
  FileName  string `column:"file_name"`
  FullPath  string `column:"full_path"`
  //Other     string
}

package main
// go get -u github.com/bogem/id3v2
import (
  "context"
  "flag"
  "fmt"
  "log"
  "path/filepath"
  "strconv"
  "strings"
  "github.com/apache/beam/sdks/go/pkg/beam"
  "github.com/apache/beam/sdks/go/pkg/beam/io/databaseio"
  "github.com/apache/beam/sdks/go/pkg/beam/io/textio"
  "github.com/apache/beam/sdks/go/pkg/beam/x/beamx"
  "github.com/bogem/id3v2"
  _ "github.com/go-sql-driver/mysql"
)
var (
  mp3File          = flag.String("mp3_list", "", "File containing all Mp3 files")
  databaseHost     = flag.String("database_host", "localhost", "Database host")
  databaseUser     = flag.String("database_user", "", "Database user")
  databasePassword = flag.String("database_password", "", "Database password")
  database         = flag.String("database", "googleplay_raw", "Database name")
)
type Id3Data struct {
  Artist    string `column:"artist"`   // TPE1
  Title     string `column:"title"`    // TIT2
  Album     string `column:"album"`    // TALB
  Year      int    `column:"year"`     // TYER
  Genre     string `column:"genre"`    // TCON
  TrackPos  int    `column:"trackPos"` // TRCK
  TrackMax  int    `column:"maxTrackPos"`
  PartOfSet string `column:"partOfSet"` // TPOS
  FileName  string `column:"file_name"`
  FullPath  string `column:"full_path"`
  //Other     string
}
func (s Id3Data) getCols() []string {
  return []string{"artist", "title", "album", "year", "genre", "trackPos", "maxTrackPos", "partOfSet", "file_name", "full_path"}
}
func convTrackpos(pos string) (int, int) {
  if pos != "" {
    data := strings.Split(pos, "/")
    fmt.Println(data)
    if len(data) > 1 {
      trck, err1 := strconv.Atoi(data[0])
      mtrck, err2 := strconv.Atoi(data[1])
      if err1 == nil && err2 == nil {
        return trck, mtrck
      }
    } else if len(data) == 1 {
      trck, err := strconv.Atoi(data[0])
      if err == nil {
        return trck, -1
      }
    }
  }
  return -1, -1
}
func getAllTags(tag id3v2.Tag) []string {
  all := tag.AllFrames()
  keys := make([]string, len(all))
  i := 0
  for k := range all {
    // Skip APIC, PRIV (album image binary)
    if k != "APIC" {
      keys[i] = k
    }
    i++
  }
  for i := range keys {
    fmt.Printf("%v: %v\n", keys[i], tag.GetTextFrame(keys[i]))
  }
  return keys
}
func parseMp3ToTags(path string) (Id3Data, error) {
  tag, err := id3v2.Open(path, id3v2.Options{Parse: true})
  if err != nil {
    return Id3Data{}, err
  }
  defer tag.Close()
  //getAllTags(*tag)
  year, _ := strconv.Atoi(tag.GetTextFrame("TYER").Text)
  tpos, mpos := convTrackpos(tag.GetTextFrame("TRCK").Text)
  return Id3Data{
    Artist:    tag.GetTextFrame("TPE1").Text,
    Title:     tag.GetTextFrame("TIT2").Text,
    Album:     tag.GetTextFrame("TALB").Text,
    Genre:     tag.GetTextFrame("TCON").Text,
    Year:      year,
    TrackPos:  tpos,
    TrackMax:  mpos,
    PartOfSet: tag.GetTextFrame("TPOS").Text,
    FileName:  filepath.Base(path),
    FullPath:  path,
    //Other:     getAllTags(tag),
  }, nil
}
func (f *Id3Data) ProcessElement(path string, emit func(Id3Data)) {
  data, err := parseMp3ToTags(path)
  if err != nil {
    fmt.Printf("Error: %\n", err)
    return
  }
  emit(data)
}
func process(s beam.Scope, t interface{}, cols []string, inDir, dsn, table string) {
  // Read
  lines := textio.Read(s, inDir)
  data := beam.ParDo(s, t, lines)
  // Write to DB
  databaseio.Write(s, "mysql", dsn, table, cols, data)
}
func main() {
  flag.Parse()
  if *mp3File == "" || *databasePassword == "" {
    log.Fatalf("Usage: extract_id3v2 --mp3_list=$TRACK_DIR --database_password=$PW [--database_host=$HOST --database_user=$USER]")
  }
  dsn := fmt.Sprintf("%v:%v@tcp(%v:3306)/%v", *databaseUser, *databasePassword, *databaseHost, *database)
  // Initialize Beam
  beam.Init()
  p := beam.NewPipeline()
  s := p.Root()
  process(s, &Id3Data{}, Id3Data{}.getCols(), *mp3File, dsn, "id3v2")
  // Run until we find errors
  if err := beamx.Run(context.Background(), p); err != nil {
    log.Fatalf("Failed to execute job: %v", err)
  }
}

2021/02/27 11:38:37 written 511 row(s) into song
2021/02/27 11:38:37 written 15 row(s) into radio
2021/02/27 11:38:37 written 1982 row(s) into playlists
1.57s user 0.25s system 135% cpu 1.336 total

2021/02/27 11:40:16 written 493 row(s) into id3v2
1.54s user 0.23s system 135% cpu 1.309 total

find $(pwd)/Music -type f -name "*.mp3" > all_mp3_master.txt
go run extract_id3v2.go utils.go \
  --mp3_list="$(pwd)/all_mp3_master.txt" \
  --database_host=$DB_HOST \
  --database_user=$DB_USER \
  --database_password="${PW}" \
  --database=googleplay_master | grep "unsupported version of ID3" >> unsup.txt
2021/02/27 12:25:09 written 8668 row(s) into id3v2
go run extract_id3v2.go utils.go --mp3_list="$(pwd)/all_mp3_master.txt"      5.45s user 1.16s system 92% cpu 7.115 total

SELECT s.artist AS csv_arist, i.artist AS mp3_artist
FROM googleplay_raw.song AS s
LEFT OUTER JOIN googleplay_raw.id3v2 AS i
ON LOWER(i.artist) = LOWER(s.artist)
ORDER BY i.artist ASC

SELECT
  s.artist AS csv_arist
  ,i.artist AS mp3_artist
  ,s.album  AS csv_album
  ,i.album AS mp3_album
  ,s.title AS csv_title
  ,i.title  AS mp3_title
  ,s.file_name
FROM googleplay_raw.song AS s
LEFT OUTER JOIN googleplay_raw.id3v2 AS i
ON (
  TRIM(LOWER(i.artist)) = TRIM(LOWER(s.artist))
  AND TRIM(LOWER(i.album)) = TRIM(LOWER(s.album))
  AND TRIM(LOWER(i.title)) = TRIM(LOWER(s.title))
  )
WHERE i.artist IS NOT NULL
ORDER BY i.artist ASC

christian @ bigiron ➜  Dev  ll clean/csv/Bite\ the\ Hand.csv
-rw-r--r-- 1 christian christian 146 Feb 27 11:04 'clean/csv/Bite the Hand.csv'
christian @ bigiron ➜  Dev  ll clean/mp3/Megadeth\ -\ Endgame\ -\ Bite\ the\ Hand.mp3
-rw-r--r-- 1 christian christian 9.3M Feb 27 08:50 'clean/mp3/Megadeth - Endgame - Bite the Hand.mp3'

SELECT iv2.artist, iv2.album, iv2.title, iv2.full_path
FROM  googleplay_master.id3v2 AS iv2
WHERE NOT EXISTS (
  SELECT iv.artist, iv.album, iv.title FROM googleplay_raw.id3v2 iv
)