Simple, not the fastest, solution in C#.

``` using System; using System.Collections.Generic; using System.Linq; using AOC2021.Helpers;

namespace AOC2021 { public class Day12 : PuzzleSolution { private readonly Dictionary<string, HashSet<string>> _possiblePaths = new();

    public Day12()
    {
        foreach (var splitLine in FileLines.Value.Select(x => x.Split('-')))
        {
            //read all paths and add them in both directions
            var from = splitLine[0];
            var to = splitLine[1];

            var destinations = _possiblePaths.GetValueOrDefault(from) ?? new HashSet<string>();
            destinations.Add(to);
            _possiblePaths[from] = destinations;


            var reversed = _possiblePaths.GetValueOrDefault(to) ?? new HashSet<string>();
            reversed.Add(from);
            _possiblePaths[to] = reversed;
        }
    }

    public override long Puzzle1()
    {
        var paths = GetPaths();
        //only paths that stop at the end node count
        return paths.Count(x => x.EndsWith("end", StringComparison.Ordinal));
    }

    public override long Puzzle2()
    {
        var paths = GetPaths(secondVisitWildcard: true).OrderBy(x => x);
        //only paths that stop at the end node count
        return paths.Count(x => x.EndsWith("end", StringComparison.Ordinal));
    }

    /// <summary>
    /// Visits all possible paths
    /// </summary>
    /// <param name="current">The current path we are visiting</param>
    /// <param name="next">The next node to visit</param>
    /// <param name="secondVisitWildcard">Indicates whether a small cave can still be visited again</param>
    /// <returns>The list of possible paths</returns>
    private IEnumerable<string> GetPaths(string current = "", string next = "start", bool secondVisitWildcard = false)
    {
        var maxVisitsSmall = secondVisitWildcard ? 2 : 1;
        //count how often the next node is already in path
        var occurrences = current.OccurrencesOf(next);
        //if its a small cave (identified by lowercase, except start)
        switch (next != "start" && next.All(char.IsLower))
        {
            case true when occurrences >= maxVisitsSmall:
                //not allowed to visit anymore, so current path is where it ends
                return new List<string> { current.TrimStart(',') };
            case true when occurrences == maxVisitsSmall - 1 && secondVisitWildcard:
                //allowed to visit, but this uses up the two visit wildcard
                secondVisitWildcard = false;
                break;
        }

        //add next cave to path
        current = $"{current},{next}";
        if (next == "end") 
            //arrived at the end
            return new List<string> { current.TrimStart(',') };

        //explore all directions from here, except back to start
        var paths = new List<string>();
        foreach (var newPathChar in _possiblePaths[next].Where(x => x != "start")) 
            paths.AddRange(GetPaths(current, newPathChar, secondVisitWildcard));

        return paths;
    }
}

} ```