create_graph():
    artists = create_artists() # creates vertices for artists
    for a in artists:
        g = undefiend
        if !vertex_exists(a.getGenre())
            g = create_genre(g)
        else
            g = get_genre_vertex(a.getGenre())
        # creates an directed-edge between artist and genre with f(a,g) = 0, and c(a,g)=#min_songs for a
        create_vertex(a)
        create_edge(a, g, min_songs_for(a), 0)

    genres = get_genre_vertices()
    p = create_playlist() # creates a sink
    for g in genres:
        # creates an edge between the genre and the sink (i.e. playlist) with f(g,p)=L_g, and c=g,p)=undefined currently
        create_edge(g, p, min_songs_for(g), 0)
    return create_min_flow()

create_min_flow():
    max_songs = 200
    p = get_playlist()
    for g in get_genre_vertices():
        min_songs := flow(g,s) #min songs required for genre
        max_per_musican := min_songs / g.count_artists()

        if(max_per_musican < 0):
            return error()

        # playlist already needs to be bigger thus it is impossible to build
        max_songs -= min_songs
        if max_songs < 0:
            return error()

        for a in g.get_artists_vertices():
            # max(lower, available, max) returns an integer, max amount of songs this artists
            # can get in the min flow version
            abs_songs := max(min_songs_for(a), a.getSongCount(), max_per_musican)
            min_songs -= abs_songs

            flow(a,g) = abs_songs
            capacity(a,g) = abs_songs

            flow(g,p) += flow(a,g)
            capacity(g,p) += flow(a,g)
            if min_songs < 0:
                return error()

        # If this is true then a genre has not enough artists to reach
        # the minium specified for this genre
        if min_songs > 0:
            return error()

    return increase_flow(max_songs)

increase_flow(remainder):
    p = get_playlist()
    for g in get_genre_vertices():
        for a in g.get_arists_vertices():
            if remainder > 0:
                # How many songs more can we take from this artists to increase the max flow?
                amt_songs := min(remainder, capacity(a,g)-flow(a,g))
                # Increase capacity from artists -> genre -> playlist
                capacity(a,g) += amt_songs
                capacity(g,p) += amt_songs
                remainder -= amt_songs # Reduce available amount of songs
            else:
                break
    if remainder > 50:
        return error()
    else:
        return success()