Benchmark — 96 configurations

def roman_strict(s: str) -> int | None:
    # Define the values of Roman numeral symbols
    values = {
        'I': 1, 'V': 5, 'X': 10, 'L': 50,
        'C': 100, 'D': 500, 'M': 1000
    }
    
    # Define subtractive pairs and their values
    subtractive_pairs = {
        'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90,
        'CD': 400, 'CM': 900
    }
    
    # Check for invalid characters
    for ch in s:
        if ch not in values:
            return None
    
    # Check for invalid repetitions
    # I, X, C can repeat at most 3 times
    for ch in 'IXC':
        if s.count(ch) > 3:
            return None
    
    # V, L, D cannot repeat
    for ch in 'VLD':
        if s.count(ch) > 1:
            return None
    
    # Check for invalid subtractive pairs (each at most once)
    for pair in subtractive_pairs:
        if s.count(pair) > 1:
            return None
    
    # Check for invalid combinations like 'IIII', 'VV', 'IC', 'MCMC'
    # Already covered by repetition rules, but also check for invalid subtractive patterns
    # like 'IC', 'IM', 'XD', 'XM', etc.
    invalid_subtractive = ['IC', 'IM', 'XD', 'XM', 'ID', 'II', 'VV', 'DD', 'LL']
    for pattern in invalid_subtractive:
        if pattern in s:
            return None
    
    # Check for non-increasing order (except subtractive pairs)
    # We'll parse the string and check order
    i = 0
    n = len(s)
    prev_value = float('inf')
    used_subtractive = set()
    
    while i < n:
        # Check for subtractive pair
        if i+1 < n and s[i:i+2] in subtractive_pairs:
            pair = s[i:i+2]
         
… (truncated)

def roman_strict(s: str) -> int | None:
    # Define the values of Roman numeral symbols
    values = {
        'I': 1, 'V': 5, 'X': 10, 'L': 50,
        'C': 100, 'D': 500, 'M': 1000
    }
    
    # Define subtractive pairs and their values
    subtractive_pairs = {
        'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90,
        'CD': 400, 'CM': 900
    }
    
    # Check if all characters are valid
    if not all(c in values for c in s):
        return None
    
    # Check for invalid repetitions
    # I, X, C can repeat at most 3 times
    for c in 'IXC':
        if s.count(c) > 3:
            return None
    
    # V, L, D cannot repeat
    for c in 'VLD':
        if s.count(c) > 1:
            return None
    
    # Check subtractive pairs appear at most once
    for pair in subtractive_pairs:
        if s.count(pair) > 1:
            return None
    
    # Check that subtractive pairs are used correctly:
    # They must be at the start of a "place" (i.e., not preceded by a smaller value)
    # And they must not be followed by a larger value
    # Also, symbols must be in non-increasing order except for subtractive pairs
    
    # Parse the string to check order and compute value
    i = 0
    n = len(s)
    total = 0
    prev_value = float('inf')  # start with a large value
    
    while i < n:
        # Check for subtractive pair
        if i+1 < n and s[i:i+2] in subtractive_pairs:
            pair = s[i:i+2]
            pair_value = subtractive_pairs[pair]
            # The pair must be valid: the first symbol must be less than the second
            # (which is guarante
… (truncated)

def roman_strict(s: str) -> int | None:
    # Define the values of Roman numeral symbols
    values = {
        'I': 1, 'V': 5, 'X': 10, 'L': 50,
        'C': 100, 'D': 500, 'M': 1000
    }
    
    # Define subtractive pairs and their values
    subtractive_pairs = {
        'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90,
        'CD': 400, 'CM': 900
    }
    
    # Check if all characters are valid
    if not all(c in values for c in s):
        return None
    
    # Check for invalid repetitions
    # I, X, C can repeat at most 3 times
    for c in 'IXC':
        if s.count(c) > 3:
            return None
    
    # V, L, D cannot repeat
    for c in 'VLD':
        if s.count(c) > 1:
            return None
    
    # Check subtractive pairs appear at most once
    for pair in subtractive_pairs:
        if s.count(pair) > 1:
            return None
    
    # Check that subtractive pairs are used correctly:
    # They must be at the start of a "place" (i.e., not preceded by a smaller value)
    # And they must not be followed by a larger value
    # Also, symbols must be in non-increasing order except for subtractive pairs
    
    # Parse the string to check order and compute value
    i = 0
    n = len(s)
    total = 0
    prev_value = float('inf')  # start with a large value
    
    while i < n:
        # Check for subtractive pair
        if i+1 < n and s[i:i+2] in subtractive_pairs:
            pair = s[i:i+2]
            pair_value = subtractive_pairs[pair]
            # The pair must be valid: the first symbol must be less than the second
            # (which is guarante
… (truncated)

def roman_strict(s: str) -> int | None:
    # Define the values of Roman numeral symbols
    values = {
        'I': 1, 'V': 5, 'X': 10, 'L': 50,
        'C': 100, 'D': 500, 'M': 1000
    }
    
    # Define subtractive pairs and their values
    subtractive_pairs = {
        'IV': 4, 'IX': 9, 'XL': 40, 'XC': 90,
        'CD': 400, 'CM': 900
    }
    
    # Check if all characters are valid
    if not all(c in values for c in s):
        return None
    
    # Check for invalid repetitions
    # I, X, C can repeat at most 3 times
    for c in 'IXC':
        if s.count(c) > 3:
            return None
    
    # V, L, D cannot repeat
    for c in 'VLD':
        if s.count(c) > 1:
            return None
    
    # Check subtractive pairs appear at most once
    for pair in subtractive_pairs:
        if s.count(pair) > 1:
            return None
    
    # Check that subtractive pairs are used correctly:
    # They must be at the start of a "place" (i.e., not preceded by a smaller value)
    # And they must not be followed by a larger value
    # Also, symbols must be in non-increasing order except for subtractive pairs
    
    # Parse the string to check order and compute value
    i = 0
    n = len(s)
    total = 0
    prev_value = float('inf')  # start with a large value
    
    while i < n:
        # Check for subtractive pair
        if i+1 < n and s[i:i+2] in subtractive_pairs:
            pair = s[i:i+2]
            pair_value = subtractive_pairs[pair]
            # The pair must be valid: the first symbol must be less than the second
            # (which is guarante
… (truncated)

func IPv4Valid(s string) bool {
	parts := strings.Split(s, ".")
	if len(parts) != 4 {
		return false
	}
	for _, p := range parts {
		if len(p) == 0 {
			return false
		}
		if len(p) > 1 && p[0] == '0' {
			return false
		}
		num := 0
		for _, c := range p {
			if c < '0' || c > '9' {
				return false
			}
			num = num*10 + int(c-'0')
		}
		if num > 255 {
			return false
		}
	}
	return true
}

func IPv4Valid(s string) bool {
	parts := strings.Split(s, ".")
	if len(parts) != 4 {
		return false
	}
	for _, p := range parts {
		if len(p) == 0 {
			return false
		}
		if len(p) > 1 && p[0] == '0' {
			return false
		}
		num := 0
		for _, c := range p {
			if c < '0' || c > '9' {
				return false
			}
			num = num*10 + int(c-'0')
		}
		if num > 255 {
			return false
		}
	}
	return true
}

func IPv4Valid(s string) bool {
	parts := strings.Split(s, ".")
	if len(parts) != 4 {
		return false
	}
	for _, p := range parts {
		if len(p) == 0 {
			return false
		}
		if len(p) > 1 && p[0] == '0' {
			return false
		}
		num := 0
		for _, c := range p {
			if c < '0' || c > '9' {
				return false
			}
			num = num*10 + int(c-'0')
		}
		if num > 255 {
			return false
		}
	}
	return true
}

func IPv4Valid(s string) bool {
	parts := strings.Split(s, ".")
	if len(parts) != 4 {
		return false
	}
	for _, p := range parts {
		if len(p) == 0 {
			return false
		}
		if len(p) > 1 && p[0] == '0' {
			return false
		}
		num := 0
		for _, c := range p {
			if c < '0' || c > '9' {
				return false
			}
			num = num*10 + int(c-'0')
		}
		if num > 255 {
			return false
		}
	}
	return true
}

function deepGet(obj, path) {
  if (!obj || typeof path !== "string" || path.length === 0) return null;

  const keys = path.split(".");
  let current = obj;

  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const bracketMatch = key.match(/^([^[]+)?\[(\d+)\]$/);

    if (bracketMatch) {
      const baseKey = bracketMatch[1];
      const index = parseInt(bracketMatch[2], 10);

      if (baseKey) {
        if (current == null || typeof current[baseKey] === "undefined") return null;
        current = current[baseKey];
      }

      if (current == null || !Array.isArray(current)) return null;
      if (index < 0 || index >= current.length) return null;
      current = current[index];
    } else {
      if (current == null || typeof current[key] === "undefined") return null;
      current = current[key];
    }
  }

  return current;
}

function deepGet(obj, path) {
  if (!obj || typeof path !== "string" || path.length === 0) return null;

  const keys = path.split(".");
  let current = obj;

  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const bracketMatch = key.match(/^([^[]+)?\[(\d+)\]$/);

    if (bracketMatch) {
      const baseKey = bracketMatch[1];
      const index = parseInt(bracketMatch[2], 10);

      if (baseKey) {
        if (current == null || typeof current[baseKey] === "undefined") return null;
        current = current[baseKey];
      }

      if (current == null || !Array.isArray(current)) return null;
      if (index < 0 || index >= current.length) return null;
      current = current[index];
    } else {
      if (current == null || typeof current[key] === "undefined") return null;
      current = current[key];
    }
  }

  return current;
}

function deepGet(obj, path) {
  if (!obj || typeof path !== "string" || path.length === 0) return null;

  const keys = path.split(".");
  let current = obj;

  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const bracketMatch = key.match(/^([^[]+)?\[(\d+)\]$/);

    if (bracketMatch) {
      const baseKey = bracketMatch[1];
      const index = parseInt(bracketMatch[2], 10);

      if (baseKey) {
        if (current == null || typeof current[baseKey] === "undefined") return null;
        current = current[baseKey];
      }

      if (current == null || !Array.isArray(current)) return null;
      if (index < 0 || index >= current.length) return null;
      current = current[index];
    } else {
      if (current == null || typeof current[key] === "undefined") return null;
      current = current[key];
    }
  }

  return current;
}

function deepGet(obj, path) {
  if (!obj || typeof path !== "string" || path.length === 0) return null;

  const keys = path.split(".");
  let current = obj;

  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const bracketMatch = key.match(/^([^[]+)?\[(\d+)\]$/);

    if (bracketMatch) {
      const baseKey = bracketMatch[1];
      const index = parseInt(bracketMatch[2], 10);

      if (baseKey) {
        if (current == null || typeof current[baseKey] === "undefined") return null;
        current = current[baseKey];
      }

      if (current == null || !Array.isArray(current)) return null;
      if (index < 0 || index >= current.length) return null;
      current = current[index];
    } else {
      if (current == null || typeof current[key] === "undefined") return null;
      current = current[key];
    }
  }

  return current;
}

fn mid_floor(a: i64, b: i64) -> i64 {
    // To avoid overflow of (a + b), we use the property that 
    // floor((a + b) / 2) can be calculated using a/2 + b/2 and handling the remainder.
    // However, a simpler way to handle both overflow and the floor logic is:
    // If a and b have the same sign, (a + b) / 2 is safe if we use a/2 + b/2 + adjustment.
    // But even better: Use the property that mid_floor(a, b) = floor(a/2 + b/2 + (a%2 + b%2)/2).
    // To avoid all overflow and handle negative rounding:
    if a >= 0 && b >= 0 {
        // Standard case for positive numbers
        a / 2 + b / 2 + (a % 2 + b % 2) / 2
    } else if a < 0 && b < 0 {
        // Standard case for negative numbers
        // In Rust, -3 / 2 = -1. We need floor(-1.5) = -2.
        let res = a / 2 + b / 2;
        let rem_sum = (a % 2).abs() + (b % 2).abs();
        // If there is a remainder and the sum is negative, we need to adjust for floor
        if (a % 2 != 0 || b % 2 != 0) && (a + b < 0) {
            // This part is tricky with overflow. Let's use a more robust approach:
            // mid_floor(a, b) = floor((a+b)/2).
            // If we can't add them, we use the identity:
            // floor((a+b)/2) = a/2 + b/2 + (1 if a%2 != 0 and b%2 != 0 and signs are same else 0) ... no.
        }
        // Let's use the most robust method:
        // mid_floor(a, b) is simply (a/2 + b/2) plus an adjustment if both are odd.
        // If a and b are both odd, (a+b)/2 has a .5 remainder.
        // If signs are same, floor(x.5) = x. If signs differ, floor(-x.5) = -x-1.
        0 // place
… (truncated)

fn mid_floor(a: i64, b: i64) -> i64 {
    // To avoid overflow of (a + b), we use the property that 
    // floor((a + b) / 2) is equivalent to a/2 + b/2 + adjustment.
    // However, a simpler way to handle all cases (including negatives and overflows)
    // is to use the logic: if both have same sign, result is (a/2 + b/2).
    // If different signs, we must be careful with truncation.
    
    // A robust approach that avoids overflow:
    // floor((a + b) / 2) == floor(a/2 + b/2 + (a%2 + b%2)/2)
    // But even simpler: use the property of integer division in Rust.
    // Rust's `/` truncates toward zero. We want floor (toward -inf).
    
    // Let sum = a + b. We want floor(sum / 2).
    // If sum is negative and odd, Rust's `sum / 2` returns -1 for -3/2, but we want -2.
    
    // To avoid overflow of a + b, we can use the following:
    // mid = (a / 2) + (b / 2) + remainder_adjustment
    // where remainder_adjustment handles the bits lost by truncation.
    
    let a_div = a / 2;
    let b_div = b / 2;
    let a_rem = a % 2; // -1, 0, or 1
    let b_rem = b % 2; // -1, 0, or 1
    
    // The true sum is (a_div * 2 + a_rem) + (b_div * 2 + b_rem)
    // Which is 2 * (a_div + b_div) + (a_rem + b_rem)
    // We want floor( [2 * (a_div + b_div) + (a_rem + b_rem)] / 2 )
    // This simplifies to: (a_div + b_div) + floor((a_rem + b_rem) / 2.0)
    
    let rem_sum = a_rem + b_rem;
    let adjustment = if rem_sum < 0 {
        // If rem_sum is -1 (e.g., -1 + 0), floor(-0.5) is -1
        -1
    } else if rem_sum == 0 {
        0
    } else {
        // If rem_sum is 1
… (truncated)

fn mid_floor(a: i64, b: i64) -> i64 {
    // To avoid overflow of (a + b), we use the property that 
    // floor((a + b) / 2) can be calculated using a/2 + b/2 and handling the remainder.
    // However, a simpler way to handle both overflow and the floor logic is:
    // If a and b have the same sign, (a + b) / 2 is safe if we use a/2 + b/2 + adjustment.
    // But even better: Use the property that mid_floor(a, b) = floor(a/2 + b/2 + (a%2 + b%2)/2).
    // To avoid all overflow and handle negative rounding:
    if a >= 0 && b >= 0 {
        // Standard case for positive numbers
        a / 2 + b / 2 + (a % 2 + b % 2) / 2
    } else if a < 0 && b < 0 {
        // Standard case for negative numbers
        // In Rust, -3 / 2 = -1. We need floor(-1.5) = -2.
        let res = a / 2 + b / 2;
        let rem_sum = (a % 2).abs() + (b % 2).abs();
        // If there is a remainder and the sum is negative, we need to adjust for floor
        if (a % 2 != 0 || b % 2 != 0) && (a + b < 0) {
            // This part is tricky with overflow. Let's use a more robust approach:
            // mid_floor(a, b) = floor((a+b)/2).
            // If we can't add them, we use the identity:
            // floor((a+b)/2) = a/2 + b/2 + (1 if a%2 != 0 and b%2 != 0 and signs are same else 0) ... no.
        }
        // Let's use the most robust method:
        // mid_floor(a, b) is simply (a/2 + b/2) plus an adjustment if both are odd.
        // If a and b are both odd, (a+b)/2 has a .5 remainder.
        // If signs are same, floor(x.5) = x. If signs differ, floor(-x.5) = -x-1.
        0 // place
… (truncated)

fn mid_floor(a: i64, b: i64) -> i64 {
    // To avoid overflow of (a + b), we use the property that 
    // floor((a + b) / 2) can be calculated using a/2 + b/2 and handling remainders.
    // However, a simpler way to handle all signs and prevent overflow is:
    // If a and b have the same sign, (a+b)/2 is safe if we use checked math or logic.
    // A robust approach for any i64:
    if a >= 0 && b >= 0 {
        // Both positive: standard division works, but a + b might overflow.
        // Use a/2 + b/2 + (a%2 + b%2)/2 logic or simply:
        a / 2 + b / 2 + (a % 2 + b % 2) / 2
    } else if a < 0 && b < 0 {
        // Both negative: standard division truncates toward zero.
        // We need to handle the floor logic for negative results.
        let res = a / 2 + b / 2 + (a % 2 + b % 2) / 2;
        // If there's a remainder that would push us towards negative infinity,
        // but integer division truncated it toward zero, we adjust.
        // Actually, the logic `a/2 + b/2 + (a%2 + b%2)/2` works for all signs 
        // if we ensure the "remainder" part handles the floor direction.
        // Let's use a more universal approach:
        let sum_rem = (a % 2).abs() + (b % 2).abs();
        // This is getting complex. Let's use the simplest overflow-safe mid:
        // floor((a+b)/2) == floor(a/2 + b/2 + (a%2 + b%2)/2)
        // But we must handle the sign of the remainder carefully for floor.
        
        // Correct approach: 
        // If a+b is even, result is (a+b)/2.
        // If a+b is odd, result is (a+b-1)/2 if we want floor.
        // To avoid
… (truncated)

public static class Sol
{
    public static int RoundHalf(double v)
    {
        // Math.Round with MidpointRounding.AwayFromZero rounds halves away from zero
        return (int)Math.Round(v, MidpointRounding.AwayFromZero);
    }
}

public static class Sol
{
    public static int RoundHalf(double v)
    {
        // Math.Round with MidpointRounding.AwayFromZero rounds halves away from zero
        return (int)Math.Round(v, MidpointRounding.AwayFromZero);
    }
}

public static class Sol
{
    public static int RoundHalf(double v)
    {
        // Math.Round with MidpointRounding.AwayFromZero rounds halves away from zero
        return (int)Math.Round(v, MidpointRounding.AwayFromZero);
    }
}

public static class Sol
{
    public static int RoundHalf(double v)
    {
        // Math.Round with MidpointRounding.AwayFromZero rounds halves away from zero
        return (int)Math.Round(v, MidpointRounding.AwayFromZero);
    }
}

<form action="/login" method="POST">
  <div>
    <label for="email">Email</label>
    <input type="email" id="email" name="email" required>
  </div>
  <div>
    <label for="password">Password</label>
    <input type="password" id="password" name="password" required>
  </div>
  <button type="submit">Sign in</button>
</form>

<form action="/login" method="POST">
  <div>
    <label for="email">Email</label>
    <input type="email" id="email" name="email" required>
  </div>
  <div>
    <label for="password">Password</label>
    <input type="password" id="password" name="password" required>
  </div>
  <button type="submit">Sign in</button>
</form>

<form method="POST" action="/login">
  <label for="email">Email</label>
  <input type="email" id="email" name="email" required>

  <label for="password">Password</label>
  <input type="password" id="password" name="password" required>

  <button type="submit">Sign in</button>
</form>

<form method="POST" action="/login">
  <label for="email">Email</label>
  <input type="email" id="email" name="email" required>

  <label for="password">Password</label>
  <input type="password" id="password" name="password" required>

  <button type="submit">Sign in</button>
</form>

def csv_line(line: str) -> list[str]:
    if not line:
        return ['']
    
    fields = []
    current_field = []
    in_quotes = False
    i = 0
    n = len(line)

    while i < n:
        char = line[i]

        if not in_quotes:
            if char == '"' and (not current_field or (len(current_field) == 1 and current_field[0] == '')):
                # Only a quote at the very start of a field triggers quoted mode
                in_quotes = True
                i += 1
                continue
            elif char == ',':
                fields.append("".join(current_field))
                current_field = []
                i += 1
                continue
            else:
                current_field.append(char)
        else:
            # Inside quotes
            if i + 1 < n and char == '"' and line[i+1] == '"':
                # Handle escaped double quotes ("")
                current_field.append('"')
                i += 2
                continue
            elif char == '"':
                # Closing quote
                in_quotes = False
                i += 1
                continue
            else:
                current_field.append(char)
                i += 1
        i += 1

    fields.append("".join(current_field))
    return fields

def csv_line(line: str) -> list[str]:
    if not line:
        return ['']
    
    result = []
    current_field = []
    in_quotes = False
    i = 0
    n = len(line)
    
    while i < n:
        char = line[i]
        
        if not in_quotes:
            if char == '"' and (not current_field or (len(current_field) == 1 and current_field[0] == '')):
                # Only a quote at the very start of a field triggers quoted mode
                in_quotes = True
                i += 1
                continue
            elif char == ',':
                result.append("".join(current_field))
                current_field = []
                i += 1
                continue
            else:
                current_field.append(char)
        else:
            # Inside quotes
            if i + 1 < n and char == '"' and line[i+1] == '"':
                # Handle escaped double quotes ("")
                current_field.append('"')
                i += 2
                continue
            elif char == '"':
                # Closing quote
                in_quotes = False
                i += 1
                continue
            else:
                current_field.append(char)
                i += 1
        i += 1

    # Append the last field processed
    result.append("".join(current_field))
    return result

def csv_line(line: str) -> list[str]:
    fields = []
    current = ''
    in_quotes = False
    i = 0
    while i < len(line):
        c = line[i]
        if in_quotes:
            if c == '"':
                if i + 1 < len(line) and line[i + 1] == '"':
                    current += '"'
                    i += 1
                else:
                    in_quotes = False
            else:
                current += c
        else:
            if c == '"':
                in_quotes = True
            elif c == ',':
                fields.append(current)
                current = ''
            else:
                current += c
        i += 1
    fields.append(current)
    return fields

def csv_line(line: str) -> list[str]:
    if not line:
        return ['']
    
    fields = []
    current_field = []
    in_quotes = False
    i = 0
    n = len(line)
    
    while i < n:
        char = line[i]
        
        if not in_quotes:
            if char == '"' and (not current_field or (len(current_field) == 1 and current_field[0] == '')):
                # Only a quote at the very start of a field triggers quoted mode
                in_quotes = True
                i += 1
                continue
            elif char == ',':
                fields.append("".join(current_field))
                current_field = []
                i += 1
                continue
            else:
                current_field.append(char)
        else:
            # Inside quotes
            if i + 1 < n and char == '"' and line[i+1] == '"':
                # Handle escaped double quotes ("")
                current_field.append('"')
                i += 2
                continue
            elif char == '"':
                # Closing quote
                in_quotes = False
                i += 1
                continue
            else:
                current_field.append(char)
                i += 1
        i += 1

    # Append the last field processed
    fields.append("".join(current_field))
    return fields

public static class Sol
{
    public static string Ordinal(int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException(nameof(n), "n must be non-negative");

        // Special case for numbers ending in 11, 12, or 13
        int lastTwoDigits = n % 100;
        if (lastTwoDigits == 11 || lastTwoDigits == 12 || lastTwoDigits == 13)
            return n + "th";

        // Determine suffix based on last digit
        int lastDigit = n % 10;
        string suffix = lastDigit switch
        {
            1 => "st",
            2 => "nd",
            3 => "rd",
            _ => "th"
        };

        return n + suffix;
    }
}

public static class Sol
{
    public static string Ordinal(int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException(nameof(n), "n must be non-negative");

        // Special case for numbers ending in 11, 12, or 13
        int lastTwoDigits = n % 100;
        if (lastTwoDigits == 11 || lastTwoDigits == 12 || lastTwoDigits == 13)
            return n + "th";

        // Determine suffix based on last digit
        int lastDigit = n % 10;
        string suffix = lastDigit switch
        {
            1 => "st",
            2 => "nd",
            3 => "rd",
            _ => "th"
        };

        return n + suffix;
    }
}

public static class Sol
{
    public static string Ordinal(int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException(nameof(n), "n must be non-negative");

        // Special case for numbers ending in 11, 12, or 13
        int lastTwoDigits = n % 100;
        if (lastTwoDigits == 11 || lastTwoDigits == 12 || lastTwoDigits == 13)
            return n + "th";

        // Determine suffix based on last digit
        int lastDigit = n % 10;
        string suffix = lastDigit switch
        {
            1 => "st",
            2 => "nd",
            3 => "rd",
            _ => "th"
        };

        return n + suffix;
    }
}

public static class Sol
{
    public static string Ordinal(int n)
    {
        if (n < 0)
            throw new ArgumentOutOfRangeException(nameof(n), "n must be non-negative");

        // Special case for numbers ending in 11, 12, or 13
        int lastTwoDigits = n % 100;
        if (lastTwoDigits == 11 || lastTwoDigits == 12 || lastTwoDigits == 13)
            return n + "th";

        // Determine suffix based on last digit
        int lastDigit = n % 10;
        string suffix = lastDigit switch
        {
            1 => "st",
            2 => "nd",
            3 => "rd",
            _ => "th"
        };

        return n + suffix;
    }
}

fn snake_to_camel(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut capitalize_next = false;
    let mut first_char_seen = false;

    for c in s.chars() {
        if c == '_' {
            // If we have already processed characters, the next valid char should be uppercase
            if first_char_seen {
                capitalize_next = true;
            }
        } else {
            if !first_char_seen {
                // Handle leading underscores: skip them and don't capitalize the first real char
                result.push(c);
                first_char_seen = true;
            } else if capitalize_next {
                result.push(c.to_ascii_uppercase());
                capitalize_next = false;
            } else {
                result.push(c);
            }
        }
    }

    result
}

fn snake_to_camel(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut capitalize_next = false;
    let mut first_char_found = false;

    // We iterate through characters, but we need to handle the logic 
    // of skipping underscores and uppercasing the next valid char.
    for c in s.chars() {
        if c == '_' {
            // If we encounter an underscore, the next non-underscore char should be uppercase
            if first_char_found {
                capitalize_next = true;
            }
            continue;
        }

        // If this is the very first non-underscore character, 
        // it stays lowercase (standard camelCase) or as is.
        // The prompt implies leading underscores vanish and we only uppercase 
        // characters *after* an underscore.
        if !first_char_found {
            result.push(c);
            first_char_found = true;
        } else if capitalize_next {
            result.extend(c.to_uppercase());
            capitalize_next = false;
        } else {
            result.push(c);
        }
    }

    result
}

fn snake_to_camel(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut capitalize_next = false;
    let mut first_char_found = false;

    // We iterate through characters, but we need to handle the "leading underscores" 
    // by skipping them until we find a non-underscore character.
    let chars: Vec<char> = s.chars().collect();
    let mut i = 0;

    // Skip leading underscores
    while i < chars.len() && chars[i] == '_' {
        i += 1;
    }

    // Determine the end index to handle trailing underscores
    let mut last_valid_idx = chars.len();
    while last_valid_idx > i && chars[last_valid_idx - 1] == '_' {
        last_valid_idx -= 1;
    }

    for j in i..last_valid_idx {
        let c = chars[j];
        if c == '_' {
            capitalize_next = true;
        } else {
            if capitalize_next {
                result.push(c.to_ascii_uppercase());
                capitalize_next = false;
            } else {
                result.push(c);
            }
            first_char_found = true;
        }
    }

    result
}

fn snake_to_camel(s: &str) -> String {
    let mut result = String::new();
    let chars: Vec<char> = s.chars().collect();
    let len = chars.len();
    let mut i = 0;

    // Skip leading underscores
    while i < len && chars[i] == '_' {
        i += 1;
    }

    // Process the rest
    while i < len {
        if chars[i] == '_' {
            // Skip all consecutive underscores
            while i < len && chars[i] == '_' {
                i += 1;
            }
            // If there's a next character, uppercase it if it's alphabetic
            if i < len {
                let c = chars[i];
                if c.is_ascii_alphabetic() {
                    result.push(c.to_ascii_uppercase());
                } else {
                    result.push(c);
                }
                i += 1;
            }
        } else {
            result.push(chars[i]);
            i += 1;
        }
    }

    // Remove trailing underscores (they would have been skipped already, but let's be safe)
    // Actually, trailing underscores are already skipped at the start, and in the loop,
    // if we have underscores at the end, they get skipped when we enter the while loop
    // and then the condition `i < len` fails, so they're naturally ignored.
    // But wait: what about underscores that are not followed by anything?
    // They are just skipped. So no need to trim.

    result
}

long long bit_count_range(int a, int b) {
    /**
     * Helper function to count total set bits from 0 up to n (inclusive).
     * Uses the property that at each bit position i (0-indexed), 
     * the pattern of 0s and 1s repeats every 2^(i+1) integers.
     */
    auto long long count_to_n(long long n) {
        if (n < 0) return 0;
        long long total = 0;
        long long range_size = n + 1;
        for (int i = 0; i < 32; i++) {
            long long period = 1LL << (i + 1);
            long long full_periods = range_size / period;
            total += full_periods * (period / 2);
            
            long long remainder = range_size % period;
            if (remainder > (period / 2)) {
                total += (remainder - (period / 2));
            }
        }
        return total;
    }

    // Total bits in [a, b] is count(b) - count(a-1)
    // We use long long for calculations to prevent overflow during subtraction/logic
    long long upper = (long long)b;
    long long lower = (long long)a;

    // Using a helper logic inside the function scope
    // Since standard C doesn't support nested functions, we implement the logic inline.
    auto count_bits_upto = [](long long n) -> long long {
        long long count = 0;
        for (int i = 0; i < 31; i++) {
            long long bit_val = 1LL << i;
            // Number of full blocks of size 2^(i+1)
            long long full_blocks = (n + 1) / (bit_val * 2);
            count += full_blocks * bit_val;
            // Remaining bits in the incomplete block
            long long remaining = (n + 1) % (bit
… (truncated)

long long bit_count_range(int a, int b) {
    /**
     * Helper function to count total set bits from 0 up to n (inclusive).
     * Uses the property that at each bit position i (0-indexed), 
     * the pattern of 0s and 1s repeats every 2^(i+1) integers.
     */
    auto long long count_to_n(long long n) {
        if (n < 0) return 0;
        long long total = 0;
        long long range_size = n + 1;
        for (int i = 0; i < 32; i++) {
            long long period = 1LL << (i + 1);
            long long full_periods = range_size / period;
            total += full_periods * (period / 2);
            
            long long remainder = range_size % period;
            if (remainder > (period / 2)) {
                total += (remainder - (period / 2));
            }
        }
        return total;
    }

    // Total bits in [a, b] is count(b) - count(a-1)
    // We use long long for calculations to prevent overflow during subtraction/logic
    long long upper = (long long)b;
    long long lower = (long long)a;

    // Using a helper logic inside the function scope
    // Since standard C doesn't support nested functions, we implement the logic inline.
    auto count_bits_upto = [](long long n) -> long long {
        long long count = 0;
        for (int i = 0; i < 31; i++) {
            long long bit_val = 1LL << i;
            // Number of full blocks of size 2^(i+1)
            long long full_blocks = (n + 1) / (bit_val * 2);
            count += full_blocks * bit_val;
            // Remaining bits in the incomplete block
            long long remaining = (n + 1) % (bit
… (truncated)

long long bit_count_range(int a, int b) {
    // Count total set bits for all integers from 0 to n
    // Then result is count(b) - count(a-1)
    if (a > b) return 0;
    
    // Function to count total set bits from 0 to n
    long long count_set_bits_upto(int n) {
        if (n < 0) return 0;
        long long count = 0;
        int i = 0;
        while ((1 << i) <= n) {
            // For each bit position i, count how many numbers from 0 to n have that bit set
            int full_cycles = (n + 1) / (1 << (i + 1));
            int remainder = (n + 1) % (1 << (i + 1));
            int partial = remainder - (1 << i);
            if (partial < 0) partial = 0;
            count += (long long)full_cycles * (1 << i) + partial;
            i++;
        }
        return count;
    }
    
    long long result = count_set_bits_upto(b) - count_set_bits_upto(a - 1);
    return result;
}

long long bit_count_range(int a, int b) {
    if (a > b) return 0;
    
    // Helper function to count set bits from 0 to n
    long long count_bits_to_n(int n) {
        if (n <= 0) return 0;
        long long count = 0;
        long long i = 1;
        
        while (i <= (long long)n) {
            long long divisor = i * 2;
            long long full_cycles = (long long)(n + 1) / divisor;
            count += full_cycles * i;
            
            long long remainder = (long long)(n + 1) % divisor;
            if (remainder > i) {
                count += remainder - i;
            }
            
            i <<= 1;
        }
        
        return count;
    }
    
    return count_bits_to_n(b) - count_bits_to_n(a - 1);
}

def dedent_text(s: str) -> str:
    lines = s.split('\n')
    # Find the longest common leading whitespace prefix
    # Only consider non-empty, non-whitespace-only lines for the prefix
    common_prefix = None
    for line in lines:
        if line and line != '':
            # This line has content, consider its leading whitespace
            leading = ''
            for ch in line:
                if ch in (' ', '\t'):
                    leading += ch
                else:
                    break
            if common_prefix is None:
                common_prefix = leading
            else:
                # Find the common prefix between common_prefix and leading
                # The common prefix must be a prefix of both
                min_len = min(len(common_prefix), len(leading))
                new_prefix = ''
                for i in range(min_len):
                    if common_prefix[i] == leading[i]:
                        new_prefix += leading[i]
                    else:
                        break
                common_prefix = new_prefix
    # Now strip the common_prefix from each line
    result = []
    for line in lines:
        if line and line != '':
            # Strip the common_prefix from the beginning
            if common_prefix and line.startswith(common_prefix):
                result.append(line[len(common_prefix):])
            else:
                result.append(line)
        else:
            result.append('')
    return '\n'.join(result)

def dedent_text(s: str) -> str:
    if not s:
        return ""

    lines = s.split('\n')
    
    # Identify lines that are not empty or whitespace-only to find the common prefix
    content_lines = [line for line in lines if line.strip()]
    
    if not content_lines:
        # If no content lines exist, all non-empty lines become empty strings
        return '\n'.join(['' if not line.strip() else line for line in lines])

    # Find the minimum common leading whitespace prefix among content lines
    # We look at each character index of the shortest line
    min_prefix_len = None
    
    for line in content_lines:
        # Count leading whitespace characters (spaces and tabs)
        count = 0
        for char in line:
            if char in (' ', '\t'):
                count += 1
            else:
                break
        
        if min_prefix_len is None or count < min_prefix_len:
            min_prefix_len = count

    # If for some reason no prefix was found (shouldn't happen with content lines)
    if min_prefix_len is None:
        min_prefix_len = 0

    result = []
    for line in lines:
        if not line.strip():
            # Lines that are empty or whitespace-only become empty strings
            result.append("")
        else:
            # Remove the common prefix from content lines
            result.append(line[min_prefix_len:])

    return '\n'.join(result)

def dedent_text(s: str) -> str:
    if not s:
        return s
    
    lines = s.split('\n')
    # Find the minimum leading whitespace among non-empty lines
    min_indent = float('inf')
    
    for line in lines:
        # Skip empty or whitespace-only lines
        if not line.strip():
            continue
        
        # Count leading whitespace characters
        indent = 0
        for char in line:
            if char in ' \t':
                indent += 1
            else:
                break
        
        if indent < min_indent:
            min_indent = indent
    
    # If no non-empty lines found, return original
    if min_indent == float('inf'):
        return s
    
    # Remove the common leading whitespace from each line
    result_lines = []
    for line in lines:
        # If line is empty or whitespace-only, make it empty
        if not line.strip():
            result_lines.append('')
            continue
        
        # Remove exactly min_indent characters from the beginning
        result_lines.append(line[min_indent:])
    
    return '\n'.join(result_lines)

def dedent_text(s: str) -> str:
    if not s:
        return s
    
    lines = s.split('\n')
    # Find the minimum leading whitespace among non-empty lines
    min_indent = float('inf')
    
    for line in lines:
        # Skip empty or whitespace-only lines for computing the minimum indent
        if line.strip() == '':
            continue
        
        # Count leading whitespace characters (tabs and spaces are different)
        indent = 0
        for char in line:
            if char in ' \t':
                indent += 1
            else:
                break
        
        if indent < min_indent:
            min_indent = indent
    
    # If no non-empty lines found, return original string
    if min_indent == float('inf'):
        return s
    
    # Remove the common leading whitespace from all lines
    result_lines = []
    for line in lines:
        # For empty or whitespace-only lines, make them empty
        if line.strip() == '':
            result_lines.append('')
        else:
            # Remove exactly min_indent characters from the beginning
            result_lines.append(line[min_indent:])
    
    return '\n'.join(result_lines)

#include <string>
#include <sstream>

int wrap_count(const std::string& s, int width) {
    if (s.empty()) return 0;
    
    std::istringstream iss(s);
    std::string word;
    int lines = 0;
    int current_line_length = 0;
    
    while (iss >> word) {
        if (word.length() > width) {
            // Word longer than width, placed alone on its own line
            lines++;
            current_line_length = 0;
        } else {
            if (lines == 0) {
                lines = 1;
                current_line_length = word.length();
            } else if (current_line_length + 1 + word.length() <= width) {
                // Word fits on current line
                current_line_length += 1 + word.length();
            } else {
                // Word doesn't fit, start new line
                lines++;
                current_line_length = word.length();
            }
        }
    }
    
    return lines;
}

int wrap_count(const std::string& s, int width) {
    if (s.empty()) return 0;
    
    int lines = 0;
    size_t pos = 0;
    size_t len = s.length();
    
    while (pos < len) {
        // Skip leading spaces
        while (pos < len && s[pos] == ' ') {
            pos++;
        }
        if (pos >= len) break;
        
        // Find the next word
        size_t word_start = pos;
        while (pos < len && s[pos] != ' ') {
            pos++;
        }
        size_t word_len = pos - word_start;
        
        // Check if word fits on current line (or starts new line)
        if (lines == 0 || word_len > width) {
            // First word or word too long: starts new line
            lines++;
            // If word is longer than width, it still occupies one line
            // and we move past it
        } else {
            // Check if word fits with previous words on current line
            // We need to track current line length
            // Since we don't track it explicitly, we'll use a different approach:
            // Process words and simulate line building
        }
    }
    
    // Better approach: simulate line building
    lines = 0;
    pos = 0;
    len = s.length();
    
    while (pos < len) {
        // Skip leading spaces
        while (pos < len && s[pos] == ' ') {
            pos++;
        }
        if (pos >= len) break;
        
        // Find next word
        size_t word_start = pos;
        while (pos < len && s[pos] != ' ') {
            pos++;
        }
        size_t word_len = pos - word_start;
        
        // Check if we need
… (truncated)

int wrap_count(const std::string& s, int width) {
    if (s.empty()) return 0;
    
    std::istringstream iss(s);
    std::string word;
    int lines = 0;
    int current_line_length = 0;
    
    while (iss >> word) {
        if (word.length() > width) {
            // Word longer than width goes on its own line
            lines++;
            current_line_length = 0;
        } else if (current_line_length == 0) {
            // First word on line
            current_line_length = word.length();
        } else if (current_line_length + 1 + word.length() <= width) {
            // Word fits with a space
            current_line_length += 1 + word.length();
        } else {
            // Start new line
            lines++;
            current_line_length = word.length();
        }
    }
    
    // Count the last line if it has content
    if (current_line_length > 0) {
        lines++;
    }
    
    return lines;
}

#include <string>
#include <sstream>

int wrap_count(const std::string& s, int width)
{
    if (s.empty()) return 0;
    if (width <= 0) {               // degenerate case: each word on its own line
        std::istringstream ss(s);
        return static_cast<int>(std::distance(std::istream_iterator<std::string>{ss},
                                              std::istream_iterator<std::string>{}));
    }

    std::istringstream iss(s);
    std::string word;
    int lines = 0;
    int cur_len = 0;                 // length of the line currently being built

    while (iss >> word) {
        int wlen = static_cast<int>(word.size());

        if (wlen > width) {          // word too long → its own line
            if (cur_len != 0) ++lines;   // finish previous line, if any
            ++lines;                     // the oversized word occupies a line alone
            cur_len = 0;
            continue;
        }

        if (cur_len == 0) {          // start a new line with this word
            cur_len = wlen;
        } else {
            // need one space before the next word
            if (cur_len + 1 + wlen <= width) {
                cur_len += 1 + wlen; // fits on current line
            } else {
                ++lines;             // close current line
                cur_len = wlen;      // start new line with this word
            }
        }
    }

    if (cur_len != 0) ++lines;       // count the last partially‑filled line
    return lines;
}

import re

def semver_cmp(a: str, b: str) -> int:
    def parse_version(v: str):
        # Remove build metadata (everything after '+')
        base = v.split('+', 1)[0]
        
        # Split version into core and pre-release parts
        if '-' in base:
            core_part, pre_release_part = base.split('-', 1)
            pre_release = pre_release_part.split('.')
        else:
            core_part = base
            pre_release = None
            
        # Parse major, minor, patch
        core = [int(x) for x in core_part.split('.')]
        
        # Process pre-release identifiers
        processed_pre = []
        if pre_release is not None:
            for part in pre_release:
                if part.isdigit():
                    processed_pre.append((0, int(part))) # Numeric type 0
                else:
                    processed_pre.append((1, part))      # String type 1
        
        return core, processed_pre

    core_a, pre_a = parse_version(a)
    core_b, pre_b = parse_version(b)

    # 1. Compare Major, Minor, Patch
    for i in range(3):
        if core_a[i] > core_b[i]: return 1
        if core_a[i] < core_b[i]: return -1

    # 2. Handle Pre-release precedence rule:
    # A version WITH a pre-release tag has LOWER precedence than one WITHOUT.
    if pre_a is not None and pre_b is None:
        return -1
    if pre_a is None and pre_b is not None:
        return 1
    if pre_a is None and pre_b is None:
        return 0

    # 3. Compare Pre-release identifiers
    for part_a, part_b in zip(pre_a, pre_b):
        # type_a/type_b (0 for int, 
… (truncated)

def semver_cmp(a: str, b: str) -> int:
    def parse_version(version_str):
        # Remove build metadata (after '+')
        if '+' in version_str:
            version_str = version_str.split('+')[0]
        
        # Split into main version and pre-release
        if '-' in version_str:
            main_part, prerelease_part = version_str.split('-', 1)
        else:
            main_part = version_str
            prerelease_part = None
        
        # Parse main version (major.minor.patch)
        parts = main_part.split('.')
        major = int(parts[0])
        minor = int(parts[1]) if len(parts) > 1 else 0
        patch = int(parts[2]) if len(parts) > 2 else 0
        
        # Parse pre-release identifiers
        prerelease = []
        if prerelease_part:
            for identifier in prerelease_part.split('.'):
                # Check if identifier is numeric
                if identifier.isdigit():
                    prerelease.append((0, int(identifier)))
                else:
                    prerelease.append((1, identifier))
        
        return (major, minor, patch), prerelease
    
    main_a, prerelease_a = parse_version(a)
    main_b, prerelease_b = parse_version(b)
    
    # Compare main version parts
    for i in range(3):
        if main_a[i] < main_b[i]:
            return -1
        elif main_a[i] > main_b[i]:
            return 1
    
    # If main versions are equal, compare pre-release info
    # A version without pre-release has higher precedence than one with pre-release
    if prerelease_a is None and prerelease_b is None:
        
… (truncated)

def semver_cmp(a: str, b: str) -> int:
    def parse_version(v: str):
        # Split off build metadata
        if '+' in v:
            v = v.split('+', 1)[0]
        
        # Split off pre-release
        if '-' in v:
            main_part, pre_part = v.split('-', 1)
            pre = pre_part.split('.')
        else:
            main_part = v
            pre = None
        
        # Parse main version
        parts = main_part.split('.')
        major = int(parts[0])
        minor = int(parts[1])
        patch = int(parts[2])
        
        return (major, minor, patch, pre)
    
    def pre_release_key(pre):
        if pre is None:
            # No pre-release means higher precedence
            return (1, [])
        else:
            # Has pre-release, lower precedence
            # Each identifier: if all digits, compare numerically; else compare as string
            identifiers = []
            for ident in pre:
                if ident.isdigit():
                    identifiers.append((0, int(ident), ''))
                else:
                    identifiers.append((1, 0, ident))
            return (0, identifiers)
    
    ma = parse_version(a)
    mb = parse_version(b)
    
    # Compare major, minor, patch
    for i in range(3):
        if ma[i] < mb[i]:
            return -1
        elif ma[i] > mb[i]:
            return 1
    
    # Compare pre-release
    pa = pre_release_key(ma[3])
    pb = pre_release_key(mb[3])
    
    # If one has pre-release and the other doesn't
    if pa[0] == 1 and pb[0] == 0:
        return 1  # a > b (no pre > pre)
    if pa[
… (truncated)

def semver_cmp(a: str, b: str) -> int:
    def parse_version(version):
        # Split into main version and pre-release/build parts
        main_part = version.split('+')[0]
        if '-' in main_part:
            main, pre = main_part.split('-', 1)
            build = None
        else:
            main, pre, build = main_part, None, None

        # Parse major.minor.patch
        major, minor, patch = map(int, main.split('.'))

        return (major, minor, patch), pre, build

    def compare_pre(pre_a, pre_b):
        if not pre_a and not pre_b:
            return 0
        if not pre_a:
            return 1
        if not pre_b:
            return -1

        parts_a = pre_a.split('.')
        parts_b = pre_b.split('.')

        for i in range(min(len(parts_a), len(parts_b))):
            part_a, part_b = parts_a[i], parts_b[i]

            # Check if both are numeric
            if part_a.isdigit() and part_b.isdigit():
                cmp = int(part_a) - int(part_b)
                if cmp != 0:
                    return cmp
            else:
                # Compare as strings (non-numeric ranks higher than numeric)
                if part_a.isdigit():
                    return -1
                elif part_b.isdigit():
                    return 1
                else:
                    cmp = (part_a > part_b) - (part_a < part_b)
                    if cmp != 0:
                        return cmp

        # If all compared parts are equal, longer pre-release is greater
        return len(parts_a) - len(parts_b)

    main_a, pre_a, _ = parse_version(a)
    main_
… (truncated)

def quoted_split(s: str) -> list | None:
    tokens = []
    current_token = []
    in_quotes = False
    i = 0
    n = len(s)
    
    # Track if we are currently processing a token (to handle empty strings/whitespace)
    # We need to know if the current sequence of characters is "active"
    has_content = False

    while i < n:
        char = s[i]

        if in_quotes:
            if char == '\\':
                if i + 1 < n and (s[i+1] == '"' or s[i+1] == '\\'):
                    current_token.append(s[i+1])
                    i += 2
                    has_content = True
                    continue
                else:
                    # Treat backslash as literal if not escaping quote/backslash
                    current_token.append(char)
            elif char == '"':
                in_quotes = False
                has_content = True
            else:
                current_token.append(char)
            i += 1
        else:
            if char in (' ', '\t'):
                if has_content or (not has_content and len(current_token) > 0):
                    # This handles the case where a token was just closed
                    tokens.append("".join(current_token))
                    current_token = []
                    has_content = False
                elif i > 0 and s[i-1] == '"':
                    # Special case: "" is an empty token
                    # If we just finished a quote, it's already handled by the logic below
                    pass
                i += 1
            elif char == '"':
                in_quotes = True
       
… (truncated)

def quoted_split(s: str) -> list | None:
    tokens = []
    current_token = []
    in_quotes = False
    i = 0
    n = len(s)
    
    # Track if we are currently processing a token (to handle empty strings/whitespace)
    # We need to know if the current sequence of characters is "active"
    has_content = False

    while i < n:
        char = s[i]

        if in_quotes:
            if char == '\\':
                if i + 1 < n and (s[i+1] == '"' or s[i+1] == '\\'):
                    current_token.append(s[i+1])
                    i += 2
                    has_content = True
                    continue
                else:
                    # Treat backslash as literal if not escaping quote/backslash
                    current_token.append(char)
            elif char == '"':
                in_quotes = False
                has_content = True
            else:
                current_token.append(char)
            i += 1
        else:
            if char in (' ', '\t'):
                if has_content or (not has_content and len(current_token) > 0):
                    # This handles the case where a token was just closed
                    tokens.append("".join(current_token))
                    current_token = []
                    has_content = False
                elif i > 0 and s[i-1] == '"':
                    # Special case: "" is an empty token
                    # If we just finished a quote, it's already handled by the logic below
                    pass
                i += 1
            elif char == '"':
                in_quotes = True
       
… (truncated)

func RleDecode(s string) string {
    var result strings.Builder
    i := 0
    for i < len(s) {
        // Expect a letter
        if i >= len(s) {
            return ""
        }
        c := s[i]
        if !isLetter(c) {
            return ""
        }
        i++
        // Expect a non-empty count with no leading zeros
        if i >= len(s) {
            return ""
        }
        // Check for leading zero
        if s[i] == '0' {
            return ""
        }
        // Parse the count
        count := 0
        for i < len(s) && s[i] >= '0' && s[i] <= '9' {
            d := int(s[i] - '0')
            count = count*10 + d
            i++
        }
        if count == 0 {
            return ""
        }
        // Append the letter count times
        for j := 0; j < count; j++ {
            result.WriteByte(c)
        }
    }
    return result.String()
}

func RleDecode(s string) string {
	if len(s) == 0 {
		return ""
	}
	var sb strings.Builder
	i := 0
	n := len(s)
	for i < n {
		// Expect a letter
		ch := s[i]
		if ch < 'a' || ch > 'z' {
			return ""
		}
		i++
		// Expect at least one digit
		if i >= n {
			return ""
		}
		// Check for leading zero
		if s[i] == '0' {
			return ""
		}
		// Parse the count
		count := 0
		for i < n && s[i] >= '0' && s[i] <= '9' {
			digit := int(s[i] - '0')
			count = count*10 + digit
			i++
		}
		if count == 0 {
			return ""
		}
		for j := 0; j < count; j++ {
			sb.WriteByte(ch)
		}
	}
	return sb.String()
}

int round_to(int n, int m) {
    int q = n / m;
    int r = n % m;
    if (r * m < 0 && -r * m >= m / 2) {
        return (q - (r < 0 ? 1 : 0)) * m;
    }
    return q * m;
}

int round_to(int n, int m) {
    if (m <= 0) return n;
    
    // Handle positive and negative numbers separately to avoid truncation issues
    if (n >= 0) {
        return ((n + m / 2) / m) * m;
    } else {
        // For negative numbers, we need to round away from zero on exact halves
        // n is negative, so let's work with absolute value conceptually
        // We want: if n = -k*m - r where 0 <= r < m, then:
        //   if r == 0: result is n (already a multiple)
        //   if r > 0 and r < m/2: round toward zero -> n + r = n - (-r) ... let's think differently
        
        // Alternative approach: use division that rounds toward negative infinity for the quotient
        // For negative n, C division truncates toward zero, so n/m is like ceil(|n|/m) in magnitude but positive direction
        
        // Let's compute the remainder properly
        int abs_n = -n;  // since n < 0
        int r = abs_n % m;
        
        if (r == 0) {
            return n;
        }
        
        // Now we have n = -(q*m + r) where q >= 0, 0 < r < m
        // We want to round away from zero on exact halves
        // So if r > m/2 or (r == m/2 and m is even, i.e., exact half), we round further from zero
        // If r < m/2, we round toward zero
        
        // For exact half: r == m/2 requires m to be even
        int threshold = m / 2;
        
        if (r > threshold || (m % 2 == 0 && r == threshold)) {
            // Round away from zero: make the magnitude larger
            // n is negative, so we subtract more
            return n - m;
        } else 
… (truncated)

int round_to(int n, int m) {
    if (m <= 0) return n;
    
    // Handle positive and negative numbers separately to avoid truncation issues
    if (n >= 0) {
        return ((n + m / 2) / m) * m;
    } else {
        // For negative numbers, we need to round away from zero on exact halves
        // n is negative, so let's work with absolute value conceptually
        // We want: if n = -k*m - r where 0 <= r < m, then:
        //   if r == 0: result is n (already a multiple)
        //   if r > 0 and r < m/2: round toward zero -> n + r = n - (-r) ... let's think differently
        
        // Alternative approach: use division that rounds toward negative infinity for the quotient
        // For negative n, C division truncates toward zero, so n/m is like ceil(|n|/m) in magnitude but positive direction
        
        // Let's compute the remainder properly
        int abs_n = -n;  // since n < 0
        int r = abs_n % m;
        
        if (r == 0) {
            return n;
        }
        
        // Now we have n = -(q*m + r) where q >= 0, 0 < r < m
        // We want to round away from zero on exact halves
        // So if r > m/2 or (r == m/2 and m is even, i.e., exact half), we round further from zero
        // If r < m/2, we round toward zero
        
        // For exact half: r == m/2 requires m to be even
        int threshold = m / 2;
        
        if (r > threshold || (m % 2 == 0 && r == threshold)) {
            // Round away from zero: make the magnitude larger
            // n is negative, so we subtract more
            return n - m;
        } else 
… (truncated)

int round_to(int n, int m) {
    if (m <= 0) return n;
    
    // Handle positive and negative numbers separately to avoid truncation issues
    if (n >= 0) {
        return ((n + m / 2) / m) * m;
    } else {
        // For negative numbers, we need to round away from zero on exact halves
        // n is negative, so let's work with absolute value conceptually
        // We want: if n = -k*m - r where 0 <= r < m, then:
        //   if r == 0: result is n (already a multiple)
        //   if r > 0 and r < m/2: round toward zero -> n + r = n - (-r) ... let's think differently
        
        // Alternative approach: use division that rounds toward negative infinity for the quotient
        // For negative n, C division truncates toward zero, so n/m is like ceil(|n|/m) in magnitude but positive direction
        
        // Let's compute the remainder properly
        int abs_n = -n;  // since n < 0
        int r = abs_n % m;
        
        if (r == 0) {
            return n;
        }
        
        // Now we have n = -(q*m + r) where q >= 0, 0 < r < m
        // We want to round away from zero on exact halves
        // So if r > m/2 or (r == m/2 and m is even, i.e., exact half), we round further from zero
        // If r < m/2, we round toward zero
        
        // For exact half: r == m/2 requires m to be even
        int threshold = m / 2;
        
        if (r > threshold || (m % 2 == 0 && r == threshold)) {
            // Round away from zero: make the magnitude larger
            // n is negative, so we subtract more
            return n - m;
        } else 
… (truncated)

def base_convert(s: str, frm: int, to: int) -> str | None:
    """Convert an integer written in base `frm` to a string in base `to`.

    Supports bases 2‑36 inclusive.
    Input may have a leading '-', and any number of leading zeros.
    Digits are 0‑9 then A‑Z (case‑insensitive). Output uses lowercase
    letters, has no leading zeros, and zero is represented as "0"
    without a sign.

    Returns None for:
      * empty input or input consisting only of a sign,
      * characters not valid in the source base,
      * bases outside 2..36.
    """
    # ----- validate bases -------------------------------------------------
    if not (2 <= frm <= 36) or not (2 <= to <= 36):
        return None

    if not s:
        return None

    # ----- sign handling --------------------------------------------------
    negative = False
    if s[0] == '-':
        negative = True
        s_body = s[1:]
    else:
        s_body = s

    if not s_body:                     # only a sign, no digits
        return None

    # ----- digit validation & conversion to integer -----------------------
    value = 0
    for ch in s_body:
        # map character to numeric value (case‑insensitive)
        if '0' <= ch <= '9':
            digit = ord(ch) - ord('0')
        elif

def base_convert(s: str, frm: int, to: int) -> str | None:
    """Convert an integer written in base `frm` to a string in base `to`.

    Supports bases 2‑36 inclusive.
    Input may have a leading '-', and any number of leading zeros.
    Digits are 0‑9 then A‑Z (case‑insensitive). Output uses lowercase
    letters, has no leading zeros, and zero is represented as "0"
    without a sign.

    Returns None for:
      * empty input or input consisting only of a sign,
      * characters not valid in the source base,
      * bases outside 2..36.
    """
    # ----- validate bases -------------------------------------------------
    if not (2 <= frm <= 36) or not (2 <= to <= 36):
        return None

    if not s:
        return None

    # ----- sign handling --------------------------------------------------
    negative = False
    if s[0] == '-':
        negative = True
        s_body = s[1:]
    else:
        s_body = s

    if not s_body:                     # only a sign, no digits
        return None

    # ----- digit validation & conversion to integer -----------------------
    value = 0
    for ch in s_body:
        # map character to numeric value (case‑insensitive)
        if '0' <= ch <= '9':
            digit = ord(ch) - ord('0')
        elif

def base_convert(s: str, frm: int, to: int) -> str | None:
    # Validate bases
    if frm < 2 or frm > 36 or to < 2 or to > 36:
        return None
    
    if not s:
        return None
    
    # Check for sign
    negative = False
    start = 0
    if s[0] == '-':
        negative = True
        start = 1
    elif s[0] == '+':
        start = 1
    
    if start == len(s):
        return None  # Only sign
    
    # Convert from base frm to integer
    num = 0
    for i in range(start, len(s)):
        c = s[i]
        if '0' <= c <= '9':
            d = ord(c) - ord('0')
        elif 'a' <= c.lower() <= 'z':
            d = ord(c.lower()) - ord('a') + 10
        else:
            return None
        if d >= frm:
            return None
        num = num * frm + d
    
    if negative:
        num = -num
    
    # Convert integer to base to
    if num == 0:
        return '0'
    
    digits = '0123456789abcdefghijklmnopqrstuvwxyz'
    result = []
    n = abs(num)
    while n > 0:
        result.append(digits[n % to])
        n //= to
    
    return ''.join(reversed(result))

def base_convert(s: str, frm: int, to: int) -> str | None:
    """Convert an integer written in base `frm` to a string in base `to`.

    Parameters
    ----------
    s : str
        Input representation (may start with '-', may contain leading zeros,
        digits 0‑9 and letters a‑z/A‑Z).
    frm, to : int
        Bases, must be between 2 and 36 inclusive.

    Returns
    -------
    str | None
        The converted number using lowercase letters, no leading zeros,
        sign only if the value is non‑zero and negative; ``None`` for any
        invalid input.
    """
    # ---- validate bases -------------------------------------------------
    if not (2 <= frm <= 36) or not (2 <= to <= 36):
        return None

    # ---- empty string check ---------------------------------------------
    if not s:
        return None

    # ---- sign handling --------------------------------------------------
    negative = False
    if s[0] == '-':
        negative = True
        s_body = s[1:]
    else:
        s_body = s

    # after removing a possible sign the body must contain at least one char
    if not s_body:
        return None

    # ---- character validation & conversion to integer -------------------
    def char_value(ch: str) -> int | None:
        """Return numeric value of a digit/letter, or None if invalid."""
        if '0' <= ch <= '9':
            return ord(ch) - 48
        lo = ch.lower()
        if 'a' <= lo <= 'z':
            return ord(lo) - 87   # 'a' -> 10
        return None

    for c in s_body:
        val = char_value(c)
        if val is None or 
… (truncated)

def justify(words: list, width: int) -> list:
    result = []
    i = 0
    n = len(words)
    
    while i < n:
        # Find how many words can fit in current line
        line_words = []
        line_length = 0
        
        while i < n and line_length + len(words[i]) + (1 if line_words else 0) <= width:
            line_words.append(words[i])
            line_length += len(words[i]) + (1 if line_words else 0)
            i += 1
        
        # Build the line
        if i == n or len(line_words) == 1:
            # Last line or single word line: left-justified
            line = ' '.join(line_words)
            line += ' ' * (width - len(line))
        else:
            # Distribute spaces evenly with extra spaces on left gaps
            total_spaces = width - sum(len(word) for word in line_words)
            gaps = len(line_words) - 1
            base_spaces = total_spaces // gaps
            extra_spaces = total_spaces % gaps
            
            # Build line with extra spaces on left gaps
            line_parts = []
            for j, word in enumerate(line_words):
                line_parts.append(word)
                if j < len(line_words) - 1:
                    # Add base spaces + extra spaces for left gaps
                    spaces = base_spaces + (1 if j < extra_spaces else 0)
                    line_parts.append(' ' * spaces)
            line = ''.join(line_parts)
        
        result.append(line)
    
    return result

def justify(words: list, width: int) -> list:
    """
    Perform full text justification.
    
    Pack as many words per line as fit with at least one space between them.
    Pad each line to exactly width by distributing spaces between words as evenly as possible,
    putting the extra spaces on the LEFT gaps first.
    The last line, and any line holding a single word, is left justified with the remaining space on the right.
    """
    if not words:
        return []
    
    # Group words into lines
    lines = []
    current_line = []
    current_length = 0
    
    for word in words:
        # Check if adding this word exceeds the width
        # At least one space between words, so new length = current_length + 1 (space) + len(word)
        if current_line and current_length + 1 + len(word) > width:
            lines.append(current_line)
            current_line = [word]
            current_length = len(word)
        else:
            current_line.append(word)
            current_length += (1 + len(word)) if current_line else len(word)
    
    if current_line:
        lines.append(current_line)
    
    # Now justify each line except the last
    result = []
    for i, line in enumerate(lines):
        if i == len(lines) - 1:
            # Last line: left-justified
            result.append(' '.join(line).ljust(width))
        elif len(line) == 1:
            # Single word: left-justified
            result.append(line[0].ljust(width))
        else:
            # Full justification
            total_words_len = sum(len(w) for w in line)
            gaps = len(line
… (truncated)

def justify(words: list, width: int) -> list:
    """
    Full‑justify a list of words into lines of exactly *width* characters.

    Rules
    -----
    1. Pack as many words per line as fit, leaving at least one space between them.
    2. For every line except the last **and** lines that contain only one word:
       distribute the required spaces as evenly as possible; any leftover spaces
       are placed in the leftmost gaps.
    3. The last line and any single‑word line are left‑justified: words are joined
       by a single space and the remaining blanks are appended on the right.

    Parameters
    ----------
    words : list[str]
        List of words to be justified (already stripped of whitespace).
    width : int
        Desired line length; all returned strings have exactly this length.

    Returns
    -------
    list[str]
        The justified lines.
    """
    res = []
    i, n = 0, len(words)

    while i < n:
        # ---- determine the words that fit on the current line ----
        line_len = len(words[i])          # length of first word
        j = i + 1                         # index after the last word in this line
        while j < n and line_len + 1 + len(words[j]) <= width:
            line_len += 1 + len(words[j])   # add one space plus next word
            j += 1

        line_words = words[i:j]
        is_last_line = (j == n)

        # ---- build the line ------------------------------------
        if len(line_words) == 1 or is_last_line:
            # left‑justified: single spaces between words, pad on the right
            line = " ".j
… (truncated)

def justify(words: list, width: int) -> list:
    """
    Full‑justify a list of words into lines of exactly *width* characters.

    Rules
    -----
    1. Pack as many words per line as fit, leaving at least one space between them.
    2. For every line except the last **and** lines that contain only one word:
       distribute the required spaces as evenly as possible; any leftover spaces
       are placed in the leftmost gaps.
    3. The last line and any single‑word line are left‑justified: words are joined
       by a single space and the remaining blanks are appended on the right.

    Parameters
    ----------
    words : list[str]
        List of words to be justified (already stripped of whitespace).
    width : int
        Desired line length; all returned strings have exactly this length.

    Returns
    -------
    list[str]
        The justified lines.
    """
    res = []
    i, n = 0, len(words)

    while i < n:
        # ---- determine the words that fit on the current line ----
        line_len = len(words[i])          # length of first word
        j = i + 1                         # index after the last word in this line
        while j < n and line_len + 1 + len(words[j]) <= width:
            line_len += 1 + len(words[j])   # add one space plus next word
            j += 1

        line_words = words[i:j]
        is_last_line = (j == n)

        # ---- build the line ------------------------------------
        if len(line_words) == 1 or is_last_line:
            # left‑justified: single spaces between words, pad on the right
            line = " ".j
… (truncated)

function parseQuery(qs) {
    const result = {};
    if (!qs || qs.length === 0) return result;

    // Remove leading '?' if present
    const queryString = qs.startsWith('?') ? qs.slice(1) : qs;

    // Split into pairs
    const pairs = queryString.split('&');
    for (const pair of pairs) {
        if (!pair) continue; // Skip empty pairs

        // Split on first '=' only
        const [key, value] = pair.split('=', 2);

        // Decode the key and value
        const decode = (str) => str.replace(/\+/g, ' ').replace(/%[0-9a-f]{2}/gi, char =>
            String.fromCharCode(parseInt(char.slice(1), 16))
        );

        const decodedKey = decode(key);
        const decodedValue = value !== undefined ? decode(value) : '';

        // Handle repeated keys
        if (result.hasOwnProperty(decodedKey)) {
            const existing = result[decodedKey];
            if (Array.isArray(existing)) {
                existing.push(decodedValue);
            } else {
                result[decodedKey] = [existing, decodedValue];
            }
        } else {
            result[decodedKey] = decodedValue;
        }
    }

    return result;
}

/**
 * Parses a URL query string into a plain object.
 *
 * @param {string} qs The query string to parse.
 * @returns {object} A plain object representing the parsed query string.
 */
const parseQuery = (qs) => {
  if (!qs) {
    return {};
  }

  if (qs.startsWith('?')) {
    qs = qs.slice(1);
  }

  const result = {};
  const pairs = qs.split('&');

  for (const pair of pairs) {
    if (!pair) {
      continue;
    }

    const [key, value] = pair.split('=', 1);

    let decodedKey = key ? decodeURIComponent(key.replace(/\+/g, ' ')) : '';
    let decodedValue = value !== undefined ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';


    if (result.hasOwnProperty(decodedKey)) {
      if (!Array.isArray(result[decodedKey])) {
        result[decodedKey] = [result[decodedKey]];
      }
      result[decodedKey].push(decodedValue);
    } else {
      result[decodedKey] = decodedValue;
    }
  }

  return result;
};

/**
 * Parses a URL query string into a plain object.
 *
 * @param {string} qs The query string to parse.
 * @returns {object} A plain object representing the parsed query string.
 */
const parseQuery = (qs) => {
  if (!qs) {
    return {};
  }

  if (qs.startsWith('?')) {
    qs = qs.slice(1);
  }

  const result = {};
  const pairs = qs.split('&');

  for (const pair of pairs) {
    if (!pair) {
      continue;
    }

    const [key, value] = pair.split('=', 1);

    let decodedKey = key ? decodeURIComponent(key.replace(/\+/g, ' ')) : '';
    let decodedValue = value !== undefined ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';


    if (result.hasOwnProperty(decodedKey)) {
      if (!Array.isArray(result[decodedKey])) {
        result[decodedKey] = [result[decodedKey]];
      }
      result[decodedKey].push(decodedValue);
    } else {
      result[decodedKey] = decodedValue;
    }
  }

  return result;
};

/**
 * Parses a URL query string into a plain object.
 *
 * @param {string} qs The query string to parse.
 * @returns {object} A plain object representing the parsed query string.
 */
const parseQuery = (qs) => {
  if (!qs) {
    return {};
  }

  if (qs.startsWith('?')) {
    qs = qs.slice(1);
  }

  const result = {};
  const pairs = qs.split('&');

  for (const pair of pairs) {
    if (!pair) {
      continue;
    }

    const [key, value] = pair.split('=', 1);

    let decodedKey = key ? decodeURIComponent(key.replace(/\+/g, ' ')) : '';
    let decodedValue = value !== undefined ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';


    if (result.hasOwnProperty(decodedKey)) {
      if (!Array.isArray(result[decodedKey])) {
        result[decodedKey] = [result[decodedKey]];
      }
      result[decodedKey].push(decodedValue);
    } else {
      result[decodedKey] = decodedValue;
    }
  }

  return result;
};

<?php

function slugify(string $s): string {
    $s = strtolower($s);
    $s = preg_replace('/[^a-z0-9]+/', '-', $s);
    $s = trim($s, '-');
    return $s;
}

?>

<?php

function slugify(string $s): string {
    $s = strtolower($s);
    $s = preg_replace('/[^a-z0-9]+/', '-', $s);
    $s = trim($s, '-');
    return $s;
}

?>

<?php

function slugify(string $s): string {
    $s = strtolower($s);
    $s = preg_replace('/[^a-z0-9]+/', '-', $s);
    $s = trim($s, '-');
    return $s;
}

?>

<?php

function slugify(string $s): string {
    $s = strtolower($s);
    $s = preg_replace('/[^a-z0-9]+/', '-', $s);
    $s = trim($s, '-');
    return $s;
}

?>

body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
  margin: 0;
}

main {
  flex: 1;
}

footer {
  /* footer naturally stays at the bottom due to flexbox layout */
}

html, body {
  height: 100%;
  margin: 0;
}

body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

main {
  flex: 1;
}

footer {
  /* Footer stays at the bottom because main grows to fill available space */
}

html, body {
  height: 100%;
  margin: 0;
}

body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

main {
  flex: 1;
}

footer {
  /* Footer stays at the bottom because main grows to fill available space */
}

html, body {
  height: 100%;
  margin: 0;
}

body {
  display: flex;
  flex-direction: column;
  min-height: 100vh;
}

main {
  flex: 1;
}

footer {
  /* Footer stays at the bottom because main grows to fill available space */
}

function flatten_keys(array $a): array
{
    $result = [];
    
    function _flatten(array $arr, string $prefix, array &$result): void
    {
        foreach ($arr as $key => $value) {
            $newKey = $prefix === '' ? (string)$key : $prefix . '.' . $key;
            if (is_array($value)) {
                _flatten($value, $newKey, $result);
            } else {
                $result[$newKey] = $value;
            }
        }
    }
    
    _flatten($a, '', $result);
    return $result;
}

function flatten_keys(array $a): array {
    $result = [];
    
    function _flatten($data, string $prefix, array &$result): void {
        foreach ($data as $key => $value) {
            $newKey = $prefix === '' ? (string)$key : $prefix . '.' . $key;
            if (is_array($value)) {
                _flatten($value, $newKey, $result);
            } else {
                $result[$newKey] = $value;
            }
        }
    }
    
    _flatten($a, '', $result);
    return $result;
}

<?php
function flatten_keys(array $a): array {
    $recurse = function (array $arr, string $prefix) use (&$recurse): array {
        $result = [];
        foreach ($arr as $key => $value) {
            $fullKey = $prefix === '' ? (string)$key : $prefix . '.' . $key;
            if (is_array($value)) {
                $result += $recurse($value, $fullKey);
            } else {
                $result[$fullKey] = $value;
            }
        }
        return $result;
    };
    return $recurse($a, '');
}
?>

<?php

function flatten_keys(array $a): array {
    $result = [];
    $stack = [[$a, '']];
    
    while ($stack) {
        [$current, $prefix] = array_pop($stack);
        
        foreach ($current as $key => $value) {
            $newKey = $prefix === '' ? (string)$key : $prefix . '.' . (string)$key;
            
            if (is_array($value)) {
                $stack[] = [$value, $newKey];
            } else {
                $result[$newKey] = $value;
            }
        }
    }
    
    return $result;
}

?>

function groupRanges(nums) {
  if (nums.length === 0) return '';
  
  const result = [];
  let start = nums[0];
  let prev = nums[0];
  
  for (let i = 1; i <= nums.length; i++) {
    // When we reach the end or find a non-consecutive number
    if (i === nums.length || nums[i] !== prev + 1) {
      if (start === prev) {
        result.push(String(start));
      } else {
        result.push(`${start}-${prev}`);
      }
      // Reset start for the next range
      if (i < nums.length) {
        start = nums[i];
      }
    }
    prev = nums[i - 1];
  }
  
  return result.join(',');
}

function groupRanges(nums) {
  if (nums.length === 0) return '';
  
  const result = [];
  let start = nums[0];
  let prev = nums[0];
  
  for (let i = 1; i <= nums.length; i++) {
    // When we reach the end or find a non-consecutive number
    if (i === nums.length || nums[i] !== prev + 1) {
      if (start === prev) {
        result.push(String(start));
      } else {
        result.push(`${start}-${prev}`);
      }
      // Reset start for the next range
      if (i < nums.length) {
        start = nums[i];
      }
    }
    prev = nums[i - 1];
  }
  
  return result.join(',');
}

function groupRanges(nums) {
  if (nums.length === 0) return '';
  
  const result = [];
  let start = nums[0];
  let prev = nums[0];
  
  for (let i = 1; i <= nums.length; i++) {
    // When we reach the end or find a non-consecutive number
    if (i === nums.length || nums[i] !== prev + 1) {
      if (start === prev) {
        result.push(String(start));
      } else {
        result.push(`${start}-${prev}`);
      }
      // Reset start for the next range
      if (i < nums.length) {
        start = nums[i];
      }
    }
    prev = nums[i - 1];
  }
  
  return result.join(',');
}

function groupRanges(nums) {
  if (nums.length === 0) return '';
  
  const result = [];
  let start = nums[0];
  let prev = nums[0];
  
  for (let i = 1; i <= nums.length; i++) {
    // When we reach the end or find a non-consecutive number
    if (i === nums.length || nums[i] !== prev + 1) {
      if (start === prev) {
        result.push(String(start));
      } else {
        result.push(`${start}-${prev}`);
      }
      // Reset start for the next range
      if (i < nums.length) {
        start = nums[i];
      }
    }
    prev = nums[i - 1];
  }
  
  return result.join(',');
}

fn kv_get(s: &str, key: &str) -> String {
    s.split(';')
        .filter_map(|entry| entry.split_once('='))
        .find(|(k, _)| k == key)
        .map(|(_, v)| v.to_string())
        .unwrap_or_default()
}

fn kv_get(s: &str, key: &str) -> String {
    s.split(';')
        .filter_map(|entry| entry.split_once('='))
        .find(|(k, _)| k == key)
        .map(|(_, v)| v.to_string())
        .unwrap_or_default()
}

fn kv_get(s: &str, key: &str) -> String {
    s.split(';')
        .filter_map(|entry| entry.split_once('='))
        .find(|(k, _)| k == key)
        .map(|(_, v)| v.to_string())
        .unwrap_or_default()
}

fn kv_get(s: &str, key: &str) -> String {
    s.split(';')
        .filter_map(|entry| entry.split_once('='))
        .find(|(k, _)| k == key)
        .map(|(_, v)| v.to_string())
        .unwrap_or_default()
}

#!/bin/bash

# Read all input into an array
mapfile -t versions

# Sort using version comparison
# Using a custom comparison function with sort -t. -k
# We'll pad each component to a fixed width (e.g., 10 digits) for proper numeric sorting
sort -t. -k1,1n -k2,2n -k3,3n -k4,4n -k5,5n -k6,6n -k7,7n -k8,8n -k9,9n -k10,10n <<< "${versions[*]}" | \
while IFS= read -r line; do
    # Remove leading zeros from each component for display (optional, but cleaner)
    # But since input is already in standard format, we just output as-is
    echo "$line"
done

# Alternative approach: use sort with version sort if available (GNU sort)
# If gsort is available, we can use: gsort -V
# But the problem asks for a script that works with standard tools, so we use numeric sort per component

# More robust version that handles variable number of components:
# Read lines, pad each component to fixed width, sort, then strip padding
# But the above approach works for typical 3-component versions

# Actually, let's implement a more robust solution using printf padding
# This version handles any number of components up to 10

# Read input into array
mapfile -t versions

# Create a temporary file for sorting
tmpfile=$(mktemp)
trap "rm -f $tmpfile" EXIT

for version in "${versions[@]}"; do
    # Split version into components
    IFS='.' read -ra parts <<< "$version"
    # Pad each part to 10 digits with leading zeros
    padded=""
    for part in "${parts[@]}"; do
        # Handle empty parts and ensure numeric
        if [[ "$part" =~ ^[0-9]+$ ]]; then
            padded+=$(printf "%010d" "$part").
   
… (truncated)

#!/bin/bash

# Read all input into an array
mapfile -t versions

# Sort using a custom comparison: compare each dot-separated part numerically
IFS=$'\n' sorted=($(for v in "${versions[@]}"; do
    # Convert version to a sortable string by padding each numeric part
    # Use printf to pad each component to a fixed width (e.g., 10 digits)
    printf "%010d" $(echo "$v" | tr '.' ' ')
    printf "\t%s\n" "$v"
done | sort -n | cut -f2-))

# Output sorted versions
printf "%s\n" "${sorted[@]}"

#!/bin/bash

# Sort version strings numerically, handling dot-separated components.
# Input: Version strings, one per line on stdin.
# Output: Sorted version strings, one per line on stdout.

sort -V <<< "$(<&0)"

#!/bin/bash

# Sort version strings numerically, handling dot-separated components.
# Input: Version strings, one per line on stdin.
# Output: Sorted version strings, one per line on stdout.

sort -V <<< "$(<&0)"

import re

def tokenize_expr(s: str) -> list | None:
    # Regex to find all potential tokens: numbers, operators, or parentheses
    # We use a pattern that captures sequences of digits/dots OR single characters
    pattern = r'(\d+\.?\d*|\d*\.\d+|[+\-*/()])'
    
    # First, check for invalid characters by removing valid ones and whitespace
    # Valid chars: 0-9, '.', '+', '-', '*', '/', '(', ')', and whitespace
    valid_chars_pattern = r'[0-9.+\-*/()\s]'
    if not re.fullmatch(valid_chars_pattern + r'*', s):
        return None

    tokens = []
    # We use finditer to get all matches of our token pattern
    # However, we must ensure that the sum of lengths of tokens and whitespace equals len(s)
    # To handle the "whitespace separates tokens" requirement strictly:
    # We can split by whitespace first, but operators might not be separated by spaces.
    # So we iterate through the string manually or use a regex that captures everything.
    
    # Let's use a scanner approach to ensure no invalid characters are hidden in "unmatched" parts
    scanner = re.finditer(r'(\d+\.\d+|\d+\.|\.\d+|\d+|[+\-*/()])|(\s+)|(.)', s)
    
    for match in scanner:
        num, space, invalid = match.groups()
        if invalid:
            return None
        if space:
            continue
        if num:
            # Check for multiple dots (though regex handles most, we validate logic)
            if num.count('.') > 1:
                return None
            # Convert to float if '.' exists, else int
            tokens.append(float(num) if '.' in num else int(num))
        if
… (truncated)

def tokenize_expr(s: str) -> list | None:
    """
    Tokenise an arithmetic expression.

    * Numbers are non‑negative integers or decimals (e.g. '3', '2.5').
      Integers become ``int`` objects, decimals become ``float``.
    * Operators '+', '-', '*', '/' and parentheses '(' , ')' are single‑character
      string tokens.
    * Whitespace separates tokens but is ignored.
    * A '-' is **always** an operator; it never belongs to a number.
    * Return ``None`` if any illegal character appears or a numeric literal has
      more than one decimal point, or if a decimal lacks digits on either side.
    """
    tokens = []
    i, n = 0, len(s)

    while i < n:
        ch = s[i]

        # Skip whitespace
        if ch.isspace():
            i += 1
            continue

        # Number (int or float)
        if ch.isdigit() or ch == '.':
            start = i
            dot_cnt = 0
            while i < n and (s[i].isdigit() or s[i] == '.'):
                if s[i] == '.':
                    dot_cnt += 1
                    if dot_cnt > 1:
                        return None          # more than one decimal point
                i += 1

            num_str = s[start:i]

            # Reject a lone '.' or missing digits around the decimal point
            if num_str == '.' or ('.' in num_str and (num_str.startswith('.') or num_str.endswith('.'))):
                return None

            # Convert to appropriate numeric type
            if '.' in num_str:
                tokens.append(float(num_str))
            else:
                tokens.append(int(num_str))

      
… (truncated)

def tokenize_expr(s: str) -> list | None:
    """
    Tokenise an arithmetic expression.

    * Numbers are non‑negative integers or decimals (e.g. '3', '2.5').
      Integers become ``int`` objects, decimals become ``float``.
    * Operators '+', '-', '*', '/' and parentheses '(' , ')' are single‑character
      string tokens.
    * Whitespace separates tokens but is ignored.
    * A '-' is **always** an operator; it never belongs to a number.
    * Return ``None`` if any illegal character appears or a numeric literal has
      more than one decimal point, or if a decimal lacks digits on either side.
    """
    tokens = []
    i, n = 0, len(s)

    while i < n:
        ch = s[i]

        # Skip whitespace
        if ch.isspace():
            i += 1
            continue

        # Number (int or float)
        if ch.isdigit() or ch == '.':
            start = i
            dot_cnt = 0
            while i < n and (s[i].isdigit() or s[i] == '.'):
                if s[i] == '.':
                    dot_cnt += 1
                    if dot_cnt > 1:
                        return None          # more than one decimal point
                i += 1

            num_str = s[start:i]

            # Reject a lone '.' or missing digits around the decimal point
            if num_str == '.' or ('.' in num_str and (num_str.startswith('.') or num_str.endswith('.'))):
                return None

            # Convert to appropriate numeric type
            if '.' in num_str:
                tokens.append(float(num_str))
            else:
                tokens.append(int(num_str))

      
… (truncated)

import re

def tokenize_expr(s: str) -> list | None:
    tokens = []
    for match in re.finditer(r'\s*([+-/*()]|\d+(?:\.\d+)?(?:(?=\s*[+-/*()]))?)', s):
        token = match.group().strip()
        if not token or not re.fullmatch(r'[+-/*()]|(\d+\.?\d*)', token):
            return None
        elif '.' in token:
            tokens.append(float(token))
        else:
            tokens.append(int(token) if token.isdigit() else token)
    # Check for consecutive dots and extra characters 
    if any(re.search(r'\.\.', t) or (t.replace('.','').replace('-','').isdigit() == False  and not re.match('^[+-/*()]$',t))   for t in [str(t) for t in tokens]):
        return None
    else:
        return tokens

function pluck(array $rows, string $key): array {
    return array_map(
        fn($row) => array_key_exists($key, $row) ? $row[$key] : null,
        $rows
    );
}

function pluck(array $rows, string $key): array {
    return array_map(
        fn($row) => array_key_exists($key, $row) ? $row[$key] : null,
        $rows
    );
}

function pluck(array $rows, string $key): array {
    return array_map(
        fn($row) => array_key_exists($key, $row) ? $row[$key] : null,
        $rows
    );
}

function pluck(array $rows, string $key): array {
    return array_map(
        fn($row) => array_key_exists($key, $row) ? $row[$key] : null,
        $rows
    );
}

def topo_lex(n: int, edges: list) -> list | None:
    from collections import deque

    # Build adjacency list and in-degree count
    adj = [[] for _ in range(n)]
    in_degree = [0] * n

    for u, v in edges:
        if u != v:  # Ignore self-loops (they create cycles)
            adj[u].append(v)
            in_degree[v] += 1

    # Initialize queue with nodes having zero in-degree
    q = deque()
    for i in range(n):
        if in_degree[i] == 0:
            q.append(i)

    topo_order = []
    while q:
        # To get lexicographically smallest, process nodes in order
        u = q.popleft()
        topo_order.append(u)

        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.append(v)

    # Check if topological sort is possible (no cycle)
    if len(topo_order) != n:
        return None

    return topo_order

def topo_lex(n: int, edges: list) -> list | None:
    from collections import deque

    # Build adjacency list and in-degree count
    adj = [[] for _ in range(n)]
    in_degree = [0] * n

    for u, v in edges:
        if u != v:  # Ignore self-loops (they create cycles)
            adj[u].append(v)
            in_degree[v] += 1

    # Initialize queue with nodes having zero in-degree
    q = deque()
    for i in range(n):
        if in_degree[i] == 0:
            q.append(i)

    topo_order = []
    while q:
        # To get lexicographically smallest, process nodes in order
        u = q.popleft()
        topo_order.append(u)

        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.append(v)

    # Check if topological sort is possible (no cycle)
    if len(topo_order) != n:
        return None

    return topo_order

def topo_lex(n: int, edges: list) -> list | None:
    from collections import defaultdict, deque

    # Build adjacency list and in-degree count
    adj = defaultdict(list)
    in_degree = [0] * n
    for u, v in edges:
        if u == v or u < 0 or u >= n or v < 0 or v >= n:
            continue  # Skip invalid edges (though problem says nodes are 0..n-1)
        adj[u].append(v)
        in_degree[v] += 1

    # Initialize queue with nodes having zero in-degree, sorted for lex order
    q = deque()
    for i in range(n):
        if in_degree[i] == 0:
            q.append(i)

    topo_order = []
    while q:
        # Process nodes in lexicographical order
        u = q.popleft()
        topo_order.append(u)

        for v in sorted(adj[u]):
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.append(v)

    if len(topo_order) != n:
        return None  # Cycle detected

    return topo_order

def topo_lex(n: int, edges: list) -> list | None:
    from collections import deque

    # Build adjacency list and in-degree count
    adj = [[] for _ in range(n)]
    in_degree = [0] * n
    for u, v in edges:
        if u != v:  # Ignore self-loops as they don't affect topological order
            adj[u].append(v)
            in_degree[v] += 1

    # Initialize queue with nodes having zero in-degree, sorted lexicographically
    q = deque()
    for i in range(n):
        if in_degree[i] == 0:
            q.append(i)

    result = []
    while q:
        # Process nodes in lexicographical order
        u = q.popleft()
        result.append(u)

        for v in sorted(adj[u]):
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.append(v)

    return result if len(result) == n else None

public static class Sol
{
    public static int ClampMul(int a, int b)
    {
        if (a == 0 || b == 0) return 0;

        bool negative = (a < 0) ^ (b < 0);
        long la = Math.Abs((long)a);
        long lb = Math.Abs((long)b);
        long product = la * lb;

        if (negative)
        {
            if (product > (long)(uint.MaxValue >> 1) + 1) // overflow below int.MinValue
                return int.MinValue;
            return -(int)product;
        }
        else
        {
            if (product > int.MaxValue)
                return int.MaxValue;
            return (int)product;
        }
    }
}

public static class Sol
{
    public static int ClampMul(int a, int b)
    {
        if (a == 0 || b == 0) return 0;

        bool negative = (a < 0) ^ (b < 0);
        long la = Math.Abs((long)a);
        long lb = Math.Abs((long)b);
        long product = la * lb;

        if (negative)
        {
            if (product > (long)(uint.MaxValue >> 1) + 1) // overflow below int.MinValue
                return int.MinValue;
            return -(int)product;
        }
        else
        {
            if (product > int.MaxValue)
                return int.MaxValue;
            return (int)product;
        }
    }
}

public static class Sol
{
    public static int ClampMul(int a, int b)
    {
        if (a == 0 || b == 0) return 0;

        bool negative = (a < 0) ^ (b < 0);
        long la = Math.Abs((long)a);
        long lb = Math.Abs((long)b);
        long product = la * lb;

        if (negative)
        {
            if (product > (long)(uint.MaxValue >> 1) + 1) // overflow below int.MinValue
                return int.MinValue;
            return -(int)product;
        }
        else
        {
            if (product > int.MaxValue)
                return int.MaxValue;
            return (int)product;
        }
    }
}

public static class Sol
{
    public static int ClampMul(int a, int b)
    {
        if (a == 0 || b == 0) return 0;

        bool negative = (a < 0) ^ (b < 0);
        long la = Math.Abs((long)a);
        long lb = Math.Abs((long)b);
        long product = la * lb;

        if (negative)
        {
            if (product > (long)(uint.MaxValue >> 1) + 1) // overflow below int.MinValue
                return int.MinValue;
            return -(int)product;
        }
        else
        {
            if (product > int.MaxValue)
                return int.MaxValue;
            return (int)product;
        }
    }
}

def lru_ops(capacity: int, ops: list) -> list:
    """Simulates an LRU cache and returns results of 'get' operations.

    Args:
        capacity: The maximum capacity of the cache.
        ops: A list of operations to perform on the cache. Each operation is a list
            of the form ['put', key, value] or ['get', key].

    Returns:
        A list of results of the 'get' operations only, using -1 for a miss.
    """
    cache = {}
    usage = []  # List to track usage order (most recent last)
    results = []

    for op in ops:
        if op[0] == 'put':
            key = op[1]
            value = op[2]
            if key in cache:
                cache[key] = value
                usage.remove(key)  # Move to end (most recently used)
            else:
                if len(cache) >= capacity:
                    lru_key = usage.pop(0)  # Evict least recently used
                    del cache[lru_key]
                cache[key] = value
                usage.append(key)  # Add to end (most recently used)
        elif op[0] == 'get':
            key = op[1]
            if key in cache:
                usage.remove(key)  # Move to end (most recently used)
                usage.append(key)
                results.append(cache[key])
            else:
                results.append(-1)

    return results

def lru_ops(capacity: int, ops: list) -> list:
    """Simulates an LRU cache and returns results of 'get' operations.

    Args:
        capacity: The maximum capacity of the cache.
        ops: A list of operations to perform on the cache. Each operation is a list
            of the form ['put', key, value] or ['get', key].

    Returns:
        A list of results of the 'get' operations only, using -1 for a miss.
    """
    cache = {}
    usage = []  # List to track usage order (most recent last)
    results = []

    for op in ops:
        if op[0] == 'put':
            key = op[1]
            value = op[2]
            if key in cache:
                cache[key] = value
                usage.remove(key)  # Move to end (most recently used)
            else:
                if len(cache) >= capacity:
                    lru_key = usage.pop(0)  # Evict least recently used
                    del cache[lru_key]
                cache[key] = value
                usage.append(key)  # Add to end (most recently used)
        elif op[0] == 'get':
            key = op[1]
            if key in cache:
                usage.remove(key)  # Move to end (most recently used)
                results.append(cache[key])
            else:
                results.append(-1)

    return results

```python code
def lru_ops(capacity: int, ops: list) -> list:
    cache = {}
    usage_order = []
    
    def update_usage(key):
        if key in usage_order:
            usage_order.remove(key)
        usage_order.append(key)
    
    results = []
    
    for op in ops:
        if op[0] == 'put':
            key, value = op[1], op[2]
            if key in cache:
                cache[key] = value
                update_usage(key)
            else:
                if len(cache) >= capacity:
                    lru_key = usage_order.pop(0)
                    del cache[lru_key]
                cache[key] = value
                update_usage(key)
        elif op[0] == 'get':
            key = op[1]
            if key in cache:
                update_usage(key)
                results.append(cache[key])
            else:
                results.append(-1)
    
    return results
```

```python code
def lru_ops(capacity: int, ops: list) -> list:
    cache = {}
    usage_order = []
    
    def update_usage(key):
        if key in usage_order:
            usage_order.remove(key)
        usage_order.append(key)
    
    results = []
    
    for op in ops:
        if op[0] == 'put':
            key, value = op[1], op[2]
            if key in cache:
                cache[key] = value
                update_usage(key)
            else:
                if len(cache) >= capacity:
                    lru_key = usage_order.pop(0)
                    del cache[lru_key]
                cache[key] = value
                update_usage(key)
        elif op[0] == 'get':
            key = op[1]
            if key in cache:
                update_usage(key)
                results.append(cache[key])
            else:
                results.append(-1)
    
    return results
```

def expand_ranges(s: str) -> list | None:
    """
    Expand a comma‑separated range specification into a sorted list of unique ints.
    
    Examples
    --------
    >>> expand_ranges("1-3, 7 ,10 -12")
    [1, 2, 3, 7, 10, 11, 12]
    
    Returns None for any malformed input:
        * empty string or only whitespace
        * empty part (e.g. "1,,3" or trailing comma)
        * non‑numeric tokens
        * reversed range like "5-3"
        * more than one hyphen in a part
    """
    if not isinstance(s, str):
        return None

    s = s.strip()
    if not s:
        return None

    parts = s.split(',')
    intervals: list[tuple[int, int]] = []

    for raw_part in parts:
        part = raw_part.strip()
        if not part:                     # empty part
            return None

        if '-' in part:
            subparts = part.split('-')
           

import re

def expand_ranges(s: str) -> list | None:
    """
    Expands a spec like "1-3,7,10-12" into a sorted list of unique ints. 
    Whitespace around numbers, hyphens and commas is allowed. Overlapping ranges merge. 
    Invalid input — empty string, empty part, non-numeric, or a reversed range like "5-3" — returns None.
    """
    if not s:
        return None

    # Split by comma, allowing for surrounding whitespace
    parts = [part.strip() for part in s.split(',')]
    
    if any(not part for part in parts):
        return None

    ranges = []
    for part in parts:
        part = part.strip()
        if not part:
            # This case should be caught by the initial check, but good for robustness
            return None 

        if '-' in part:
            try:
                start_str, end_str = map(str.strip, part.split('-'))
                start = int(start_str)
                end = int(end_str)
                
                if start > end:
                    return None  # Reversed range
                
                ranges.append((start, end))
            except ValueError:
                return None  # Non-numeric part in range

        else:
            try:
                num = int(part)
                ranges.append((num, num))
            except ValueError:
                return None  # Non-numeric standalone part

    if not ranges:
        # Should be caught by the initial check, but handles case where s was just commas/spaces resulting in empty parts list if logic above failed slightly
        return None

    # 1. Sort ranges ba
… (truncated)

import re

def expand_ranges(s: str) -> list | None:
    """
    Expands a spec like "1-3,7,10-12" into a sorted list of unique ints. 
    Whitespace around numbers, hyphens and commas is allowed. Overlapping ranges merge. 
    Invalid input — empty string, empty part, non-numeric, or a reversed range like "5-3" — returns None.
    """
    if not s:
        return None

    # Normalize whitespace and split by comma
    parts = [part.strip() for part in s.split(',')]
    
    if any(not part for part in parts):
        return None

    ranges = []
    for part in parts:
        part = part.strip()
        if not part:
            return None

        if '-' in part:
            try:
                start_str, end_str = map(str.strip, part.split('-'))
                start = int(start_str)
                end = int(end_str)
                
                if start > end:
                    return None  # Reversed range
                
                ranges.append((start, end))
            except ValueError:
                return None  # Non-numeric part in range
        else:
            try:
                num = int(part)
                ranges.append((num, num))
            except ValueError:
                return None  # Non-numeric standalone part

    if not ranges:
        # Should be caught by the initial empty string check, but for safety
        return None

    # Sort ranges based on start point
    ranges.sort()

    # Merge overlapping ranges and expand to list of unique integers
    merged_ranges = []
    if ranges:
        current_start, current_end = ran
… (truncated)

def expand_ranges(s: str) -> list | None:
    if not s.strip():
        return None
    ranges = [part.split('-') for part in s.replace(',', '-').split()]
    result = set()
    for r in ranges:
        if len(r) != 2 or not all(x.strip().isdigit() for x in r):
            return None
        start, end = int(r[0]), int(r[1])
        if start > end:
            return None
        result.update(range(start, end + 1))
    return sorted(list(result))

def path_norm(path: str) -> str:
    if not path:
        return '/'
    
    # Split path into components
    components = []
    current = ''
    
    for char in path:
        if char == '/':
            if current:
                components.append(current)
                current = ''
        else:
            current += char
    
    # Add the last component if it exists
    if current:
        components.append(current)
    
    # Process components
    stack = []
    
    for component in components:
        if component == '.' or component == '':
            # Skip current directory references and empty components
            continue
        elif component == '..':
            # Go up one level if possible
            if stack and stack[-1] != '..':
                stack.pop()
            else:
                # Stay at root if already at root
                stack.append(component)
        else:
            stack.append(component)
    
    # Handle the case where we're at the root
    # If we have a .. at the beginning, we should keep it
    result = '/' + '/'.join(stack)
    
    # If result is just '/', return it
    if result == '/':
        return '/'
    
    # Remove trailing slash
    if result.endswith('/'):
        result = result[:-1]
    
    return result

def path_norm(path: str) -> str:
    if not path:
        return '/'
    
    # Split path into components
    components = []
    current = ''
    
    for char in path:
        if char == '/':
            if current:
                components.append(current)
                current = ''
        else:
            current += char
    
    # Add the last component if it exists
    if current:
        components.append(current)
    
    # Process components
    stack = []
    
    for component in components:
        if component == '.' or component == '':
            # Skip current directory references and empty components
            continue
        elif component == '..':
            # Go up one level if possible
            if stack and stack[-1] != '..':
                stack.pop()
            elif not stack or stack[-1] == '..':
                # Stay at root or add .. if already at root
                stack.append('..')
        else:
            stack.append(component)
    
    # Handle special case where we're at the root but have .. components
    # This is handled by the logic above, but let's make sure
    result = '/' + '/'.join(stack) if stack else '/'
    
    return result

def path_norm(path: str) -> str:
    if not path:
        return '/'
    
    # Split path by '/' and filter out empty strings
    parts = [part for part in path.split('/') if part]
    
    # Process parts to handle '.' and '..'
    stack = []
    for part in parts:
        if part == '.':
            continue
        elif part == '..':
            if stack and stack[-1] != '..':
                stack.pop()
            elif not stack or stack[-1] == '..':
                stack.append('..')
        else:
            stack.append(part)
    
    # Handle case where we're at root and have '..'
    # This ensures that '..' at the root stays at the root
    if not stack and path.startswith('/'):
        return '/'
    
    # Reconstruct path
    result = '/' + '/'.join(stack)
    
    # Remove trailing slash if it exists (but keep root '/')
    if result != '/' and result.endswith('/'):
        result = result[:-1]
    
    return result

def path_norm(path: str) -> str:
    if not path:
        return '/'
    
    # Split path into components
    components = []
    current = ''
    
    for char in path:
        if char == '/':
            if current:
                components.append(current)
                current = ''
            else:
                # Handle multiple consecutive slashes
                pass
        else:
            current += char
    
    # Add the last component if it exists
    if current:
        components.append(current)
    
    # Process components
    stack = []
    
    for component in components:
        if component == '.' or component == '':
            # Skip current directory references and empty components
            continue
        elif component == '..':
            # Go up one level if possible
            if stack and stack[-1] != '..':
                stack.pop()
            else:
                # Stay at root if already at root
                stack.append(component)
        else:
            stack.append(component)
    
    # Special case: if stack is empty but we started with a root, return root
    if not stack and path.startswith('/'):
        return '/'
    
    # Reconstruct the path
    result = '/' + '/'.join(stack)
    
    # Remove trailing slash (but keep root)
    if len(result) > 1 and result.endswith('/'):
        result = result[:-1]
    
    return result

import json

def json_pointer(doc, pointer: str):
    """
    Resolves an RFC 6901 JSON Pointer against doc, returning the referenced value or None if it does not resolve.

    Args:
        doc: The document (Python object) to query.
        pointer: The JSON Pointer string.

    Returns:
        The referenced value, or None if the pointer is invalid or out of bounds.
    """
    if not pointer:
        return doc

    # 1. Decode the pointer components
    def decode_token(token):
        # Handle escaped characters first (RFC 6901 specifies '~1' for '/' and '~0' for '~')
        if token == "~1":
            return "/"
        elif token == "~0":
            return "~"
        else:
            return token

    # The pointer is split by '/', but we must handle the escaped slashes first.
    # A simple split('/') will break on encoded '/' ('~1').
    # We need a custom splitting mechanism or careful replacement/splitting.

    # Since '~1' decodes to '/', and we are splitting by '/', we can temporarily
    # replace all literal '/' with a unique placeholder, then decode the escaped ones,
    # and finally split by the original separator logic (which is now safe).

    # A simpler approach based on standard library behavior for JSON Pointer decoding:
    # The pointer string needs to be decoded according to RFC 6901 rules.
    # We can use a regex or iterative replacement, but since we are implementing it manually:

    tokens = []
    current_token = ""
    i = 0
    while i < len(pointer):
        char = pointer[i]
        if char == '/':
            # If the current t
… (truncated)

import re

def json_pointer(doc, pointer: str):
    """
    Resolves an RFC 6901 JSON Pointer against doc, returning the referenced value or None if it does not resolve.

    Args:
        doc: The document (Python object) to query.
        pointer: The JSON Pointer string.

    Returns:
        The referenced value, or None if the pointer is invalid or out of bounds.
    """
    if not pointer:
        return doc

    # 1. Decode the pointer according to RFC 6901 rules for escaped characters
    def decode_token(token):
        # '~1' decodes to '/' and '~0' decodes to '~'
        # The rule states '~1' must be decoded BEFORE '~0'.
        decoded = token.replace('~1', '/').replace('~0', '~')
        return decoded

    # Split the pointer by '/', but we need a custom split/decode process because 
    # the components themselves might contain escaped slashes or tildes.
    
    # A simpler approach is to first decode the whole string, then split by '/'
    # However, standard JSON Pointer decoding requires careful handling of escapes *within* tokens.

    # Let's use a regex-based iterative decoding/splitting process that respects escaping:
    tokens = []
    current_token = ""
    i = 0
    while i < len(pointer):
        char = pointer[i]
        if char == '/':
            if current_token:
                # Decode the accumulated token before appending it
                decoded_token = decode_token(current_token)
                tokens.append(decoded_token)
                current_token = ""
            else:
                # Handle leading/consecutive slashes if th
… (truncated)

import re

def json_pointer(doc, pointer: str):
    """
    Resolves an RFC 6901 JSON Pointer against doc, returning the referenced value or None if it does not resolve.

    Args:
        doc: The document (Python object) to query.
        pointer: The JSON Pointer string.

    Returns:
        The referenced value, or None if the pointer is invalid or out of bounds.
    """
    if not pointer:
        return doc

    # 1. Decode the pointer according to RFC 6901 rules for escaped characters
    def decode_token(token):
        # '~1' decodes to '/' and '~0' decodes to '~'
        # The rule states '~1' must be decoded BEFORE '~0'.
        decoded = token.replace('~1', '/').replace('~0', '~')
        return decoded

    # Split the pointer by '/', but we need a custom split/decode process because 
    # the components themselves might contain escaped slashes or tildes.
    
    # A simpler approach is to first decode the whole string, then split by '/'
    # However, standard JSON Pointer decoding requires careful handling of escapes *within* tokens.

    # Let's use a regex-based iterative decoding/splitting process that respects escaping:
    tokens = []
    current_token = ""
    i = 0
    while i < len(pointer):
        char = pointer[i]
        if char == '/':
            if current_token:
                # Decode the accumulated token before appending it
                decoded_token = decode_token(current_token)
                tokens.append(decoded_token)
                current_token = ""
            else:
                # Handle leading/consecutive slashes if th
… (truncated)

import re

def json_pointer(doc, pointer: str):
    """
    Resolves an RFC 6901 JSON Pointer against doc, returning the referenced value or None if it does not resolve.

    Args:
        doc: The document (Python object) to query.
        pointer: The JSON Pointer string.

    Returns:
        The referenced value, or None if the pointer is invalid or out of bounds.
    """
    if not pointer:
        return doc

    # 1. Decode the pointer according to RFC 6901 rules for escaped characters
    def decode_token(token):
        # '~1' decodes to '/' and '~0' decodes to '~'
        # The rule states '~1' must be decoded BEFORE '~0'.
        decoded = token.replace('~1', '/').replace('~0', '~')
        return decoded

    # Split the pointer by '/', but we need a custom split/decode process because 
    # the components themselves might contain escaped slashes or tildes.
    
    # A simpler approach is to first decode the whole string, then split by '/'
    # However, standard JSON Pointer decoding requires careful handling of escapes *within* tokens.

    # Let's use a regex-based iterative decoding/splitting process that respects escaping:
    tokens = []
    current_token = ""
    i = 0
    while i < len(pointer):
        char = pointer[i]
        if char == '/':
            if current_token:
                # Decode the accumulated token before appending it
                decoded_token = decode_token(current_token)
                tokens.append(decoded_token)
                current_token = ""
            else:
                # Handle leading/consecutive slashes if th
… (truncated)

int clamp_add(int a, int b) {
    if (a > INT_MAX - b) return INT_MAX;
    if (a < INT_MIN - b) return INT_MIN;
    return a + b;
}

int clamp_add(int a, int b) {
    if (a > INT_MAX - b) return INT_MAX;
    if (a < INT_MIN - b) return INT_MIN;
    return a + b;
}

int clamp_add(int a, int b) {
    if (a > INT_MAX - b) return INT_MAX;
    if (a < INT_MIN - b) return INT_MIN;
    return a + b;
}

int clamp_add(int a, int b) {
    if (a > INT_MAX - b) return INT_MAX;
    if (a < INT_MIN - b) return INT_MIN;
    return a + b;
}

def ring(capacity: int, ops: list) -> list:
    buffer = [None] * capacity
    head = 0  # index of the oldest element
    count = 0  # number of elements currently in the buffer
    results = []
    
    for op in ops:
        if op[0] == 'push':
            value = op[1]
            if count == capacity:
                # Buffer is full, overwrite the oldest element
                head = (head + 1) % capacity
            else:
                count += 1
            buffer[head] = value
        elif op[0] == 'pop':
            if count == 0:
                results.append(None)
            else:
                result = buffer[head]
                head = (head + 1) % capacity
                count -= 1
                results.append(result)
    
    return results

 def ring(capacity, ops):
    buffer = []
    results = []
    
    for op in ops:
        if op[0] == 'push':
            if len(buffer) < capacity:
                buffer.append(op[1])
            else:
                buffer.pop(0)  # Remove the oldest element to make space
                buffer.append(op[1])
        elif op[0] == 'pop':
            results.append(buffer.pop(0) if len(buffer) > 0 else None)
    
    return results  

 def ring(capacity, ops):
    buffer = []
    results = []
    
    for op in ops:
        if op[0] == 'push':
            if len(buffer) < capacity:
                buffer.append(op[1])
            else:
                buffer.pop(0)  # Remove the oldest element to make space
                buffer.append(op[1])
        elif op[0] == 'pop':
            results.append(buffer.pop(0) if len(buffer) > 0 else None)
    
    return results  

 def ring(capacity, ops):
    buffer = []
    results = []
    
    for op in ops:
        if op[0] == 'push':
            if len(buffer) < capacity:
                buffer.append(op[1])
            else:
                buffer.pop(0)  # Remove the oldest element from the front of the list
                buffer.append(op[1])
        elif op[0] == 'pop':
            if len(buffer) > 0:
                results.append(buffer.pop(0))  # Remove and return the oldest element from the front of the list
            else:
                results.append(None)
    
    return results  

#include <string>

std::string csv_escape(std::string field) {
    bool needs_quoting = false;
    for (char c : field) {
        if (c == ',' || c == '"') {
            needs_quoting = true;
            break;
        }
    }
    if (!needs_quoting) {
        return field;
    }
    std::string escaped;
    escaped.reserve(field.size() + 2);
    escaped += '"';
    for (char c : field) {
        if (c == '"') {
            escaped += "\"";
        } else {
            escaped += c;
        }
    }
    escaped += '"';
    return escaped;
}

#include <string>

std::string csv_escape(const std::string& field) {
    if (field.empty()) return "";
    size_t comma_pos = field.find(',');
    size_t quote_pos = field.find('"');
    bool has_comma = (comma_pos != std::string::npos && comma_pos <= field.size() - 1);
    bool has_quote = (quote_pos != std::string::npos && quote_pos <= field.size() - 2);
    if (has_comma || has_quote) {
        size_t start = 0;
        std::string escaped;
        while (start < field.size()) {
            size_t end = field.find(',', start, 1);
            if (end == std::string::npos) end = field.size();
            size_t quote_end = field.find('"', start + 1);
            if (quote_end != std::string::npos && quote_end <= end - 2) {
                escaped += '"';
                for (size_t i = start + 1; i < quote_end; ++i) {
                    char c = field[i];
                    if (c == '"') escaped += '"';
                    else escaped += c;
                }
                escaped += '"';
                start = quote_end + 1;
            } else {
                size_t sub_start = end > start ? end : std::string::npos;
                for (size_t i = start; i < field.size() && i <= sub_start; ++i) {
                    char c = field[i];
                    if (c == '"') escaped += '"';
                    else escaped += c;
                }
                start = sub_start + 1;
            }
        }
        return '"' + escaped + '"';
    } else {
        return field;
    }
}

#include <string>

std::string csv_escape(const std::string& field) {
    if (field.empty()) return "";
    size_t comma_pos = field.find(',');
    size_t quote_pos = field.find('"');
    bool has_comma = (comma_pos != std::string::npos && comma_pos <= field.size() - 1);
    bool has_quote = (quote_pos != std::string::npos && quote_pos <= field.size() - 2);
    if (has_comma || has_quote) {
        size_t start = 0;
        while (true) {
            size_t end = field.find('=', start + 1, 0);
            if (end == std::string::npos) break;
            size_t quote_end = field.find('"', end + 2, 0);
            if (quote_end != std::string::npos && quote_end < field.size() - 1) {
                size_t quote_len = quote_end - end - 1;
                for (size_t i = 0; i <= quote_len; ++i) {
                    char c = field[end + 2 + i];
                    if (c == '"') {
                        c = '"';
                    }
                    std::string part = field.substr(end, quote_end - end + 1);
                    size_t new_start = start;
                    size_t new_end = end + quote_len + 1;
                    std::string escaped_part = part;
                    for (size_t i = 0; i < escaped_part.size(); ++i) {
                        if (escaped_part[i] == '"') {
                            escaped_part.insert(i, 1, '"');
                            ++i;
                        }
                    }
                    field.replace(new_start, new_end - new_start, escaped_part);
                }
            } else {
                break;
           
… (truncated)

#include <string>

std::string csv_escape(const std::string& field) {
    if (field.empty()) return "";
    size_t comma_pos = field.find(',');
    size_t quote_pos = field.find('"');
    bool has_comma = (comma_pos != std::string::npos && comma_pos <= field.size() - 1);
    bool has_quote = (quote_pos != std::string::npos && quote_pos <= field.size() - 2);
    if (has_comma || has_quote) {
        size_t start = 0;
        std::string escaped;
        while (start < field.size()) {
            size_t end = field.find(',', start, 1);
            if (end == std::string::npos) end = field.size();
            size_t quote_end = field.find('"', start + 1);
            if (quote_end != std::string::npos && quote_end <= end - 2) {
                escaped += '"';
                for (size_t i = start + 1; i < quote_end; ++i) {
                    char c = field[i];
                    if (c == '"') escaped += '"';
                    else escaped += c;
                }
                escaped += '"';
                start = quote_end + 1;
            } else {
                size_t sub_start = end > start ? end : std::string::npos;
                for (size_t i = start; i < field.size() && i <= sub_start; ++i) {
                    char c = field[i];
                    if (c == '"') escaped += '"';
                    else escaped += c;
                }
                start = sub_start + 1;
            }
        }
        return '"' + escaped + '"';
    } else {
        return field;
    }
}

cat input_file.txt | your_script.sh

echo "apple\nbanana\napple\norange" | {
  declare -A seen;
  while IFS= read -r line; do
    if [[ -z ${seen[$line]} ]]; then
      echo "$line";
      seen[$line]=1;
    fi
  done;
}

echo "apple\nbanana\napple\norange" | {
  declare -A seen;
  while IFS= read -r line; do
    if [[ -z ${seen[$line]} ]]; then
      echo "$line";
      seen[$line]=1;
    fi
  done;
}

echo "apple\nbanana\napple\norange" | {
  declare -A seen;
  while IFS= read -r line; do
    if [[ -z ${seen[$line]} ]]; then
      echo "$line";
      seen[$line]=1;
    fi
  done;
}

 Here is the C function to count words in a given string:
```cpp
#include <stdio.h>
#include <ctype.h>

int count_words(const char *s) {
    int wordCount = 0;
    
    while (*s != '\0') {
        // Skip leading separators (spaces and tabs)
        while (*s == ' ' || *s == '\t') {
            s++;
        }
        
        if (*s != '\0') {
            wordCount++;
            
            // Skip the current word
            while (*s != ' ' && *s != '\t' && *s != '\0') {
                s++;
            }
        }
    }
    
    return wordCount;
}
```
This function iterates through the

 Here is the C function to count words in a given string:
```cpp
#include <stdio.h>
#include <ctype.h>

int count_words(const char *s) {
    int wordCount = 0;
    
    while (*s != '\0') {
        // Skip leading separators (spaces and tabs)
        while (*s == ' ' || *s == '\t') {
            s++;
        }
        
        if (*s != '\0') {
            wordCount++;
            
            // Skip the current word
            while (*s != ' ' && *s != '\t' && *s != '\0') {
                s++;
            }
        }
    }
    
    return wordCount;
}
```
This function iterates through the

 Here is the C function to count words in a given string:
```cpp
#include <stdio.h>
#include <ctype.h>

int count_words(const char *s) {
    int wordCount = 0;
    
    while (*s != '\0') {
        // Skip leading separators (spaces and tabs)
        while (*s == ' ' || *s == '\t') {
            s++;
        }
        
        if (*s != '\0') {
            wordCount++;
            
            // Skip the current word
            while (*s != ' ' && *s != '\t' && *s != '\0') {
                s++;
            }
        }
    }
    
    return wordCount;
}
```
This function iterates through the

 Here is the C function to count words in a given string:
```cpp
#include <stdio.h>
#include <ctype.h>

int count_words(const char *s) {
    int wordCount = 0;
    
    while (*s != '\0') {
        // Skip leading separators (spaces and tabs)
        while (*s == ' ' || *s == '\t') {
            s++;
        }
        
        if (*s != '\0') {
            wordCount++;
            
            // Skip the current word
            while (*s != ' ' && *s != '\t' && *s != '\0') {
                s++;
            }
        }
    }
    
    return wordCount;
}
```
This function iterates through the

 SELECT users.name FROM users WHERE users.id NOT IN (SELECT DISTINCT orders.user_id FROM orders) ORDER BY users.name ASC; 

 SELECT users.name FROM users WHERE users.id NOT IN (SELECT DISTINCT orders.user_id FROM orders) ORDER BY users.name ASC; 

 SELECT users.name FROM users WHERE users.id NOT IN (SELECT DISTINCT orders.user_id FROM orders) ORDER BY users.name ASC; 

 SELECT users.name FROM users WHERE users.id NOT IN (SELECT DISTINCT orders.user_id FROM orders) ORDER BY users.name ASC; 

def interval_intersect(a: list, b: list) -> list:
    i = j = 0
    res = []
    while i < len(a) and j < len(b):
        start = max(a[i][0], b[j][0])
        end = min(a[i][1], b[j][1])
        if start <= end:
            res.append([start, end])
        if a[i][1] > b[j][1]:
            i += 1
        else:
            j += 1
    return res

def interval_intersect(a: list, b: list) -> list:
    i = j = 0
    res = []
    while i < len(a) and j < len(b):
        start = max(a[i][0], b[j][0])
        end = min(a[i][1], b[j][1])
        if start <= end:
            res.append([start, end])
        if a[i][1] > b[j][1]:
            i += 1
        else:
            j += 1
    return res

def interval_intersect(a: list, b: list) -> list:
    i = j = 0
    res = []
    while i < len(a) and j < len(b):
        start = max(a[i][0], b[j][0])
        end = min(a[i][1], b[j][1])
        if start <= end:
            res.append([start, end])
        if a[i][1] > b[j][1]:
            i += 1
        else:
            j += 1
    return res

def interval_intersect(a: list, b: list) -> list:
    i = j = 0
    res = []
    while i < len(a) and j < len(b):
        start = max(a[i][0], b[j][0])
        end = min(a[i][1], b[j][1])
        if start <= end:
            res.append([start, end])
        if a[i][1] > b[j][1]:
            i += 1
        else:
            j += 1
    return res

def glob_match(pattern: str, text: str) -> bool:
    def match(text_index, pattern_index):
        if text_index == len(text) and pattern_index == len(pattern):
            return True  # Both strings are fully matched.
        elif text_index != len(text) and pattern_index == len(pattern):
            return False  # Pattern is exhausted but there's still text left.
        elif text_index == len(text) and pattern[pattern_index] == '*':
            return match(text_index, pattern_index + 1)  # Text is exhausted; skip asterisks.
        else:
            if (pattern[pattern_index] == '?' and text_index < len(text)) or (pattern[pattern_index] == text[text_index]):
                return match(text_index + 1, pattern_index + 1)  # Matched a character or question mark.
            elif pattern[pattern_index] == '*':
                return match(text_index, pattern_index + 1) or match(text_index + 1, pattern_index)  # Skip the asterisk or skip both.
            else:
                return False  # Mismatch without wildcards.
    return match(0, 0)

def glob_match(pattern: str, text: str) -> bool:
    def match(text_index, pattern_index):
        if text_index == len(text) and pattern_index == len(pattern):
            return True  # Both strings are fully matched.
        elif text_index != len(text) and pattern_index == len(pattern):
            return False  # Pattern is exhausted but there's still text left.
        elif text_index == len(text) and pattern[pattern_index] == '*':
            return match(text_index, pattern_index + 1)  # Text is exhausted; skip asterisks.
        else:
            if (pattern[pattern_index] == '?' and text_index < len(text)) or (pattern[pattern_index] == text[text_index]):
                return match(text_index + 1, pattern_index + 1)  # Matched a character or question mark.
            elif pattern[pattern_index] == '*':
                return match(text_index, pattern_index + 1) or match(text_index + 1, pattern_index)  # Skip the asterisk or skip both.
            else:
                return False  # Mismatch without wildcards.
    return match(0, 0)

We are to write a function that matches a pattern against a text without using re, fnmatch, or glob.
 The pattern uses:
   '?' matches exactly one character.
   '*' matches any sequence (including empty) of characters.

 We cannot use the built-in modules, so we have to implement the matching ourselves.

 Approach:
 We can use recursion or iterative dynamic programming. However, the problem says to return only the function.

 Let's design a recursive function that works from the beginning of the pattern and text.

 Steps:
 1. If the pattern is empty and text is empty -> True.
 2. If the pattern is empty but text is not -> False.
 3. If the text is empty but pattern is not -> then we check if pattern is all stars? But note: we can have multiple stars.

 However, note: the problem says that '*' matches any sequence including empty.

 We can do:

 Let's define a helper function that takes (i, j) where i is index in pattern and j is index in text.

 But the problem says: return only the function. We can do without helper by using recursion with two indices.

 Alternatively, we can do iterative from the start.

 However, the problem does not specify performance, but we want to be efficient enough.

 Idea: 
   We traverse the pattern and text.

 Steps for iterative:

   i = 0 (pattern index)
   j = 0 (text index)

   while i < len(pattern) and j < len(text):
        if pattern[i] == '*':
            # We have a star: we can skip the star and try to match from the next pattern character with the current text
            # But note: star can match empty, so we might want to skip th
… (truncated)

We are to write a function that matches a pattern against a text without using re, fnmatch, or glob.
 The pattern uses:
   '?' matches exactly one character.
   '*' matches any sequence (including empty) of characters.

 We cannot use the built-in modules, so we have to implement the matching.

 Approach:
 We can use recursion or iterative dynamic programming. However, the problem says to return only the function.

 Let's design a recursive function that works from the beginning of the pattern and text.

 Steps:
 1. If the pattern is empty and text is empty -> True.
 2. If pattern is empty but text is not -> False.
 3. If text is empty but pattern is not -> then we have to check if pattern is all stars? But note: '*' can match empty, so if pattern is non-empty and text is empty, then we can have pattern starting with '*' and then the rest? Actually, we have to consider the entire pattern.

 However, note: the problem says "pattern matches the whole of text".

 We can do:

 Let's define a helper function that takes (i, j) where i is index in pattern, j is index in text.

 But the problem says: return only the function. We can do without helper by recursion? But recursion might be deep.

 Alternatively, we can do iterative with two pointers.

 However, the problem does not specify performance, but we want to be efficient enough.

 Idea for iterative:

 We traverse the pattern and text.

 Steps for iterative:

  i = 0 (pattern index)
  j = 0 (text index)

  while j < len(text):
      if pattern[i] == '*':
          # We can skip this star and try to match the rest of the patte
… (truncated)

1. Write CSS implementing a two-theme token: :root defines --ink as #111111; inside an @media (prefers-color-scheme: dark) block, :root redefines --ink as #eeeeee; and body sets color to var(--ink). The trap is scope — the dark value must live inside the media query, not beside it.
Return only the CSS in a single ```css code block. 

1. Write CSS implementing a two-theme token: :root defines --ink as #111111; inside an @media (prefers-color-scheme: dark) block, :root redefines --ink as #eeeeee; and body sets color to var(--ink). The trap is scope — the dark value must live inside the media query, not beside it.
Return only the CSS in a single ```css code block. 

1. Write CSS implementing a two-theme token: :root defines --ink as #111111; inside an @media (prefers-color-scheme: dark) block, :root redefines --ink as #eeeeee; and body sets color to var(--ink). The trap is scope — the dark value must live inside the media query, not beside it.
Return only the CSS in a single ```css code block. 

1. Write CSS implementing a two-theme token: :root defines --ink as #111111; inside an @media (prefers-color-scheme: dark) block, :root redefines --ink as #eeeeee; and body sets color to var(--ink). The trap is scope — the dark value must live inside the media query, not beside it.
Return only the CSS in a single ```css code block. 

<table>
  <caption>Quarterly revenue</caption>
  <thead>
    <tr scope="col">Q1</scope>
    <th scope="col">Q2</th>
    <th scope="col">Q3</th>
  </tr>
  </thead>
  <tbody>
    <tr>
      <td>Revenue: $50,000</td>
      <td>Revenue: $65,000</td>
      <td>Revenue: $72,000</td>
    </tr>
    <tr>
      <td>Growth: 10%</td>
      <td>Growth: 8%</td>
      <td>Growth: 4%</td>
    </tr>
  </tbody>
</table>

<table>
  <caption>Quarterly revenue</caption>
  <thead>
    <tr scope="col">Q1</scope>
    <th scope="col">Q2</th>
    <th scope="col">Q3</th>
  </tr>
  </thead>
  <tbody>
    <tr>
      <td>Revenue: $50,000</td>
      <td>Revenue: $65,000</td>
      <td>Revenue: $72,000</td>
    </tr>
    <tr>
      <td>Growth: 10%</td>
      <td>Growth: 8%</td>
      <td>Growth: 4%</td>
    </tr>
  </tbody>
</table>

<table>
  <caption>Quarterly revenue</caption>
  <thead>
    <tr scope="col">Q1</scope>
    <th scope="col">Q2</th>
    <th scope="col">Q3</th>
  </tr>
  </thead>
  <tbody>
    <tr>
      <td>Revenue: $50,000</td>
      <td>Revenue: $65,000</td>
      <td>Revenue: $72,000</td>
    </tr>
    <tr>
      <td>Growth: 10%</td>
      <td>Growth: 8%</td>
      <td>Growth: 4%</td>
    </tr>
  </tbody>
</table>

<table>
  <caption>Quarterly revenue</caption>
  <thead>
    <tr scope="col">Q1</scope>
    <th scope="col">Q2</th>
    <th scope="col">Q3</th>
  </tr>
  </thead>
  <tbody>
    <tr>
      <td>Revenue: $50,000</td>
      <td>Revenue: $65,000</td>
      <td>Revenue: $72,000</td>
    </tr>
    <tr>
      <td>Growth: 10%</td>
      <td>Growth: 8%</td>
      <td>Growth: 4%</td>
    </tr>
  </tbody>
</table>

We are to compute the maximum nesting depth of round brackets in the string s.
 Steps:
 1. We traverse the string and ignore non-bracket characters.
 2. We maintain a counter for the current depth (starting at 0).
 3. When we see an opening bracket '(', we increase the counter by 1.
 4. When we see a closing bracket ')', we decrease the counter by 1.
 5. However, if at any point the counter becomes negative, that means there's a closing bracket without an opener -> not balanced -> return -1.
 6. Also, at the end, if the counter is not zero, then there are unclosed openers -> not balanced -> return -1.

 But note: the problem says "return the maximum nesting depth" if balanced, or -1 if not balanced.

 However, note: the problem says "maximum nesting depth". We are to track the maximum value of the counter during the traversal.

 Important: The problem states that non-bracket characters are ignored.

 Approach:
   Initialize:
     current_depth = 0
     max_depth = 0
     balance = 0

   For each char c in s:
     if c is '(' -> balance++ 
        then max_depth = max(max_depth, balance)
     if c is ')' -> balance--
        if balance < 0 -> return -1 (unbalanced)
     else: ignore

   After the loop, if balance != 0 -> return -1 (unclosed openers)

   But note: the problem says the empty string has depth 0.

 However, the problem says: "return the maximum nesting depth of round brackets in s"

 Example: 
   s = "()" -> max_depth = 1? 
        Actually: 
          start: balance=0, max_depth=0
          '(' -> balance=1, max_depth=1
          ')' -> balance=0 -> then max_de
… (truncated)

We are to compute the maximum nesting depth of round brackets in the string s.
 Steps:
 1. We traverse the string and ignore non-bracket characters.
 2. We maintain a counter for the current depth (starting at 0).
 3. When we see an opening bracket '(', we increase the counter by 1.
 4. When we see a closing bracket ')', we decrease the counter by 1.
 5. However, if at any point the counter becomes negative, that means there's a closing bracket without an opener -> not balanced -> return -1.
 6. Also, at the end, if the counter is not zero, then there are unclosed openers -> not balanced -> re

We are to compute the maximum nesting depth of round brackets in the string s.
 Steps:
 1. We traverse the string.
 2. We ignore non-bracket characters (only '(' and ')').
 3. We maintain a counter for the current depth (starting at 0).
 4. When we see an opening bracket '(', we increase the counter by 1 (and update the max depth if needed).
 5. When we see a closing bracket ')', we decrease the counter by 1. But note: if the counter becomes negative, that means there's a closing bracket without an opener -> unbalanced -> return -1.
 6. However, the problem says: return -1 if the brackets are 

We are to compute the maximum nesting depth of round brackets in the string s.
 Steps:
 1. We traverse the string and ignore non-bracket characters.
 2. We maintain a counter for the current depth (starting at 0).
 3. When we see an opening bracket '(', we increase the counter by 1.
 4. When we see a closing bracket ')', we decrease the counter by 1.
 5. However, if at any point the counter becomes negative, that means there's a closing bracket without an opener -> not balanced -> return -1.
 6. Also, at the end, if the counter is not zero, then there are unclosed openers -> not balanced -> re

We are to create an HTML fragment without a document shell.
 Requirements:
   - A <nav> element
   - Inside the nav, a <ul> of exactly three <li> items
   - Each <li> holds an <a> tag
   - The links point to: '/', '/about', '/contact'
   - The About link (which is the link for '/about') must carry the attribute `aria-current="page"` and only it.

 Steps:
   - We'll create a <nav> element.
   - Inside, a <ul> (unordered list).
   - Three <li> elements, each with an <a> tag.
   - The links: 
        first: href="/"
        second: href="/about" -> this one should have aria-current="page"
        third: href="/contact"

 Important: Only the About link has `aria-current="page"`.

 Note: The problem says "the About link — and only it — carries aria-current="page""

 We'll structure the list items in the order: 
   - Home (href="/")
   - About (href="/about", with aria-current="page")
   - Contact (href="/contact")

 However, note: the problem does not specify the order of the links, but typically we have Home, About, Contact.
 But the problem says: "each holding an <a>". We have to have exactly three.

 Let's write the fragment:

   <nav>
     <ul>
       <li><a href="/">Home</a></li>
       <li><a href="/about" aria-current="page">About</a></</li>
       <li><a href="/contact">Contact</a></li>
     </ul>
   </nav>

 But note: the problem says "the About link — and only it — carries aria-current="page"". So we set that attribute only on the About link.

 However, the problem does not specify the text of the links. We can use the text "Home", "About", "Contact" for clarity.

 But
… (truncated)

We are to create an HTML fragment without a document shell.
 Requirements:
   - A <nav> element
   - Inside the nav, a <ul> of exactly three <li> items
   - Each <li> holds an <a> tag
   - The links point to: '/', '/about', '/contact'
   - The About link (which is the link for '/about') must carry the attribute `aria-current="page"` and only it.

 Steps:
   - We'll create a <nav> element.
   - Inside, a <ul> (unordered list).
   - Three <li> elements, each with an <a> tag.
   - The links: 
        first: href="/"
        second: href="/about" -> this one should have aria-current="page"
        third: href="/contact"

 Important: Only the About link has `aria-current="page"`.

 Note: The problem says "the About link — and only it — carries aria-current="page""

 We'll structure the list items in the order: 
   - Home (href="/")
   - About (href="/about", with aria-current="page")
   - Contact (href="/contact")

 However, note: the problem does not specify the order of the links, but typically we have Home, About, Contact.
 But the problem says: "each holding an <a>". We have to have exactly three.

 Let's write the fragment:

   <nav>
     <ul>
       <li><a href="/">Home</a></li>
       <li><a href="/about" aria-current="page">About</a></</li>
       <li><a href="/contact">Contact</a></li>
     </ul>
   </nav>

 But note: the problem says "the About link — and only it — carries aria-current="page"". So we are only setting that on the About link.

 However, the problem does not specify the text of the links. We can use the text "Home", "About", "Contact" for clarity.

 But t
… (truncated)

We are to create an HTML fragment without a document shell.
 Requirements:
   - A <nav> element
   - Inside the nav, a <ul> of exactly three <li> items
   - Each <li> holds an <a> tag
   - The links point to: '/', '/about', '/contact'
   - The About link (which is the link for '/about') must carry the attribute `aria-current="page"` and only it.

 Steps:
   - We'll create a <nav> element.
   - Inside, a <ul> (unordered list).
   - Three <li> elements, each with an <a> tag.
   - The links: 
        first: href="/"
        second: href="/about" -> this one should have aria-current="page"
        third: href="/contact"

 Important: Only the About link has `aria-current="page"`.

 Note: The problem says "the About link — and only it — carries aria-current="page""

 We'll structure the list items in the order: 
   - Home (href="/")
   - About (href="/about", with aria-current="page")
   - Contact (href="/contact")

 However, note: the problem does not specify the order of the links, but typically we have Home, About, Contact.
 But the problem says: "each holding an <a>". We have to have exactly three.

 Let's write the fragment:

   <nav>
     <ul>
       <li><a href="/">Home</a></li>
       <li><a href="/about" aria-current="page">About</a></</li>
       <li><a href="/contact">Contact</a></li>
     </ul>
   </nav>

 But note: the problem says "the About link — and only it — carries aria-current="page"". So we are only setting that on the About link.

 However, the problem does not specify the text of the links. We can use the text as "Home", "About", "Contact" for clarity? 
 Bu
… (truncated)

We are to create an HTML fragment without a document shell.
 Requirements:
   - A <nav> element
   - Inside the nav, a <ul> of exactly three <li> items
   - Each <li> holds an <a> tag
   - The links point to: '/', '/about', '/contact'
   - The About link (which is the link for '/about') must carry aria-current="page"

 Steps:
   - We'll create the <nav> element.
   - Inside, we'll have a <ul> (unordered list).
   - We'll have three <li> elements, each with an <a> tag.
   - The links: 
        first: href="/"
        second: href="/about" -> this one should have aria-current="page"
        third: href="/contact"

 Note: The problem says "the About link — and only it — carries aria-current='page'". 
        So we set the aria-current="page" on the <a> for the about link.

 Important: We are to return only the fragment in a single HTML code block.

 Let's write the code accordingly.

 Example structure:
   <nav>
     <ul>
        <li><a href="/">Home</a></li>
        <li><a href="/about" aria-current="page">About</a></</li>
        <li><a href="/contact">Contact</a></li>
     </ul>
   </nav>

 However, note: the problem does not specify the text of the links. But the problem says "the links point to ...", so we have to have the text? 
 But the problem says: "each holding an <a>". It doesn't specify the text, but typically we have text. However, the problem does not require text? 

 Let me re-read: "each holding an <a>". It doesn't say what the text is. But in the context of a navigation, we usually have text.

 But the problem says: "Return only the fragment". And it doesn't s
… (truncated)

We are given a table `orders` with columns: customer (TEXT) and amount (INTEGER)
 We want to return each customer whose total order amount (sum of all their amounts) is at least 100.
 We need to output two columns: customer and total (the total amount for that customer)
 The result should be ordered by total descending and then by customer ascending.

 Steps:
 1. We can use a subquery to compute the total amount per customer.
 2. Then filter for total >= 100.
 3. Order by total descending and customer ascending.

 However, note: the problem says "return each customer whose ORDER TOTAL (sum of all their amounts) is at least 10:00" -> but the threshold is 100.

 Important: The problem says "at least 100", so we use >= 100.

 Let's write the query:

 We'll use:
   SELECT customer, total
   FROM (
        SELECT customer, SUM(amount) AS total
        FROM orders
        GROUP BY customer
   ) AS subquery
   WHERE total >= 100
   ORDER BY total DESC, customer ASC;

 But note: the problem says "Return only the SQL in a single sql code block."

 However, the problem says: "as two columns (customer, total)".

 Let me check: the table has `customer` and `amount`. We are grouping by customer and summing the amount.

 But note: the problem says "ORDER TOTAL (sum of all their amounts)".

 We have to be cautious: the problem says "threshold applies to the customer's total, not to individual orders".

 So the above query should work.

 However, the problem says: "Write a single SQLite SELECT"

 We can also do without a subquery by using a WHERE clause in the GROUP BY? But we need to filt
… (truncated)

We are given a table `orders` with columns: customer (TEXT) and amount (INTEGER)
 We want to return each customer whose total order amount (sum of all their amounts) is at least 100.
 We need to output two columns: customer and total (the total amount for that customer)
 The result should be ordered by total descending and then by customer ascending.

 Steps:
 1. We can use a subquery to compute the total amount per customer.
 2. Then filter for total >= 100.
 3. Order by total descending and customer ascending.

 However, note: the problem says "return each customer whose ORDER TOTAL (sum of all their amounts) is at least 10:00" -> but the threshold is 100.

 Important: The problem says "at least 100", so we use >= 100.

 Let's write the query:

 We'll use:
   SELECT customer, total
   FROM (
        SELECT customer, SUM(amount) AS total
        FROM orders
        GROUP BY customer
   ) AS subquery
   WHERE total >= 100
   ORDER BY total DESC, customer ASC;

 But note: the problem says "Return only the SQL in a single sql code block."

 However, the problem says: "as two columns (customer, total)".

 Let me check: the table has `customer` and `amount`. We are grouping by customer and summing the amount.

 But note: the problem says "ORDER TOTAL (sum of all their amounts)".

 We have to be cautious: the problem says "threshold applies to the customer's total, not to individual orders".

 So the above query should work.

 However, the problem says: "Write a single SQLite SELECT"

 We can also do without a subquery by using a WHERE clause in the GROUP BY? But we need to filt
… (truncated)

SELECT customer, total
FROM orders
WHERE amount >= 100
ORDER BY total DESC, customer ASC;

SELECT customer, total
FROM orders
WHERE amount >= 100
ORDER BY total DESC, customer ASC;

.cards {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 16px;
}

.card {
  border-radius: 8px;
  transition: transform 0.3s;
  cursor: pointer;
}

.cards {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 16px;
}

.card {
  border-radius: 8px;
  transition: transform 0.3s;
}

.cards {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 16px;
}

.card {
  border-radius: 8px;
  transition: transform 0.3s;
  cursor: pointer;
}

.cards {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));
  gap: 16px;
}

.card {
  border-radius: 8px;
  transition: transform 0.3s;
}