# Large benchmark for comprehensive stress testing
let
  range = start: end:
    if start >= end
    then []
    else [start] ++ range (start + 1) end;

  concat = a: b: a ++ b;

  factorial = n:
    if n <= 1
    then 1
    else n * factorial (n - 1);

  # Ackermann function (highly recursive)
  ackermann = m: n:
    if m == 0
    then n + 1
    else if n == 0
    then ackermann (m - 1) 1
    else ackermann (m - 1) (ackermann m (n - 1));

  # Greatest common divisor
  gcd = a: b:
    if b == 0
    then a
    else gcd b (a - (a / b) * b);

  # Power function
  pow = base: exp:
    if exp == 0
    then 1
    else if exp == 1
    then base
    else base * pow base (exp - 1);

  compose = f: g: x: f (g x);
  double = x: x * 2;
  addTen = x: x + 10;
  square = x: x * x;

  pipeline = compose square (compose double addTen);

  list_100 = range 1 101;
  list_50 = range 1 51;
  list_25 = range 1 26;

  largeAttrs = {
    a1 = 1;
    a2 = 2;
    a3 = 3;
    a4 = 4;
    a5 = 5;
    a6 = 6;
    a7 = 7;
    a8 = 8;
    a9 = 9;
    a10 = 10;
    b1 = 11;
    b2 = 12;
    b3 = 13;
    b4 = 14;
    b5 = 15;
    b6 = 16;
    b7 = 17;
    b8 = 18;
    b9 = 19;
    b10 = 20;
    c1 = 21;
    c2 = 22;
    c3 = 23;
    c4 = 24;
    c5 = 25;
    c6 = 26;
    c7 = 27;
    c8 = 28;
    c9 = 29;
    c10 = 30;
    d1 = 31;
    d2 = 32;
    d3 = 33;
    d4 = 34;
    d5 = 35;
    d6 = 36;
    d7 = 37;
    d8 = 38;
    d9 = 39;
    d10 = 40;
    e1 = 41;
    e2 = 42;
    e3 = 43;
    e4 = 44;
    e5 = 45;
    e6 = 46;
    e7 = 47;
    e8 = 48;
    e9 = 49;
    e10 = 50;
  };

  # Very deep nesting (10 levels)
  deepNest = {
    level1 = {
      level2 = {
        level3 = {
          level4 = {
            level5 = {
              level6 = {
                level7 = {
                  level8 = {
                    level9 = {
                      level10 = {
                        treasure = "found";
                        value = 12345;
                      };
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
  };

  recursiveComplex = rec {
    base = 10;
    doubled = base * 2;
    tripled = base * 3;

    sum = doubled + tripled;
    product = doubled * tripled;

    x = base * 4;
    y = x + doubled;
    z = y * tripled;

    total = sum + product + z;
    final = total * base;
  };

  config1 = rec {
    multiplier = 5;
    base = 100;
    result = base * multiplier;
  };

  config2 = rec {
    offset = 50;
    scaled = config1.result + offset;
    doubled = scaled * 2;
  };

  config3 = rec {
    factor = 3;
    combined = config2.doubled * factor;
    final = combined + config1.multiplier;
  };

  baseConfig = {
    system = {
      arch = "x86_64";
      os = "linux";
    };
    settings = {
      enabled = true;
      level = 5;
    };
  };

  overrides = {
    system = {
      kernel = "6.1";
    };
    settings = {
      level = 10;
      extra = "custom";
    };
    newSection = {
      value = 42;
    };
  };

  merged =
    baseConfig
    // overrides
    // {
      system = baseConfig.system // overrides.system;
      settings =
        baseConfig.settings
        // overrides.settings
        // {
          combined = baseConfig.settings.level + overrides.settings.level;
        };
    };

  fact10 = factorial 10;
  fact7 = factorial 7;
  ack_3_3 = ackermann 3 3;
  gcd_48_18 = gcd 48 18;
  gcd_100_35 = gcd 100 35;
  pow_2_10 = pow 2 10;
  pow_3_5 = pow 3 5;

  pipelineResult = pipeline 5; # ((5 + 10) * 2)^2 = 900

  # List operations
  concatenated = concat [1 2 3] [4 5 6];
  multilevel = concat (concat [1] [2 3]) [4 5];
in {
  # Lists
  inherit list_100 list_50 list_25 concatenated multilevel;

  # Math results
  inherit fact10 fact7 ack_3_3 gcd_48_18 gcd_100_35 pow_2_10 pow_3_5 pipelineResult;

  # Data structures
  inherit largeAttrs merged;
  deepValue = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.value;
  deepTreasure = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.treasure;

  # Recursive attrsets
  recursiveTotal = recursiveComplex.total;
  recursiveFinal = recursiveComplex.final;
  computedZ = recursiveComplex.z;

  # Config chain
  config1Result = config1.result;
  config2Doubled = config2.doubled;
  config3Final = config3.final;

  # Merged config
  mergedCombined = merged.settings.combined;
  mergedArch = merged.system.arch;
  mergedKernel = merged.system.kernel;
}