Please write a test case generator that meets the following requirements based on the following CYaRon documentation:

1. Write a canonical CYaRon Generator using Python
2. Generate test cases with at least 5 different features
3. Save each test case individually in the format [use case characteristics].in
4. Includes a variety of types such as base cases, boundary cases, large random cases, etc
5. Each use case contains clear comments to explain the design intent
6. Output is purely input data without answer validation
7. Generate all test cases in a single run


CYaRon Documentation

Input/Output (IO)
The IO library helps you easily create test data files. 

Constructor Options:
```python
# Basic file specification
IO("test1.in", "test1.out")  # Explicit input/output files
IO(file_prefix="test")  # Generates test.in and test.out
IO(file_prefix="test", data_id=3)  # Generates test3.in and test3.out

# Advanced file naming
IO(file_prefix="test", data_id=6, 
   input_suffix=".input", output_suffix=".answer")  # test6.input and test6.answer

# Partial output options
IO("test2.in")  # Only input file, output goes to temporary file
IO(file_prefix="test", data_id=5, disable_output=True)  # No output file generated
IO()  # Both files temporary (for use with comparator)
```

Note: Combine `file_prefix` and `data_id` with loops for batch generation.

IO Methods:
```python
io = IO("test1.in", "test1.out")  # Initialize IO object

# Input writing methods
io.input_write(1, 2, 3)  # Writes "1 2 3" to input file (no newline)
io.input_writeln(4, 5, 6)  # Writes "4 5 6\n" to input file
io.input_write([1, 2, 3])  # Writes list as space-separated "1 2 3"
io.input_write(1, 2, 3, separator=',')  # Writes "1,2,3," (note: current version leaves trailing comma)

# Output writing methods
io.output_write(1, 2, 3)  # Writes "1 2 3" to output file
io.output_writeln(4, 5, 6)  # Writes "4 5 6\n" to output file
io.output_write(1, 2, [1, 2, 3], [4])  # Flattens nested lists to "1 2 1 2 3 4"

# Program execution
io.output_gen("~/Documents/std")  # Runs program with input, captures stdout as output
io.output_gen("C:\\Users\\Aqours\\std.exe")  # Windows path support
```

---

Graph Generation
The Graph library generates various graph structures.

Manual Construction:
```python
# Graph initialization
graph = Graph(10)  # 10-node undirected graph (nodes 1-10)
graph = Graph(10, directed=True)  # Directed version

# Adding edges
graph.add_edge(1, 5)  # Default weight=1
graph.add_edge(1, 6, weight=3)  # Custom weight

# Edge access and properties
graph.edges  # Adjacency list containing Edge objects
for edge in graph.iterate_edges():
    edge.start  # Source node
    edge.end  # Target node
    edge.weight  # Edge weight

# Output formatting options
io.input_writeln(graph)  # Default "u v w" per line
io.input_writeln(graph.to_str(shuffle=True))  # Random edge order
io.input_writeln(graph.to_str(output=Edge.unweighted_edge))  # "u v" format
```

Template Graphs:
```python
# Basic graph templates
Graph.graph(n, m)  # n nodes, m edges (weight=1)
Graph.graph(n, m, directed=True, weight_limit=(5, 300))  # Directed with weight range
Graph.graph(n, m, self_loop=False, repeated_edges=False)  # No duplicate edges

# Special graph types
Graph.chain(n)  # n-node chain (alias for tree(n, 1, 0))
Graph.flower(n)  # n-node star graph (alias for tree(n, 0, 1))
Graph.tree(n)  # Random tree
Graph.tree(n, 0.4, 0.35)  # 40% chain-like, 35% star-like, 25% random
Graph.binary_tree(n)  # Random binary tree

# Competition-specific graphs
Graph.hack_spfa(n)  # Graph that breaks SPFA (1.5n edges)
Graph.hack_spfa(n, extra_edge=m)  # With additional edges
Graph.DAG(n, m)  # Directed Acyclic Graph
Graph.UDAG(n, m)  # Undirected Connected Graph
```

Note: Most templates support `weight_limit`, `weight_gen`, `self_loop`, and `repeated_edges` parameters.

---

Polygon
Generate and analyze polygons.

```python
# Polygon creation (points must be ordered)
p = Polygon([(0,0), (0,4), (4,4), (4,0)])  # Rectangle

# Geometric properties
p.perimeter()  # Calculates perimeter
p.area()  # Calculates area

# Generation templates
Polygon.convex_hull(n)  # n-point convex hull
Polygon.simple_polygon(n)  # Simple polygon (non-intersecting)
```

---

Vector
Generate unique vectors/number sequences.

```python
# Basic usage
Vector.random()  # Default: 5 unique numbers in [0,10]
Vector.random(10, [(10,50)])  # 10 unique numbers in [10,50]
Vector.random(30, [(10,50), 20])  # 30 unique 2D vectors

# Modes:
# 0: Unique integer vectors (default)
# 1: Non-unique integer vectors
# 2: Real-valued vectors
Vector.random(30, [(1,10), (1,10), (1,10)], 2)  # 30 3D real vectors
Vector.random(30, [10], 1)  # 30 numbers (may repeat)
```

---

String
Generate random text elements.

```python
# Basic strings
String.random(5)  # 5-character word
String.random((10,20), charset="abcd1234")  # Variable length
String.random(10, charset="#######...")  # 70% '#', 30% '.'

# Structured text
String.random_sentence(5)  # 5-word sentence
String.random_paragraph((3,10))  # 3-10 sentence paragraph

# Custom formatting
String.random_sentence(5, word_separators=["  "])  # Double space separator
```

Note: All templates support charset customization.

---

Sequence
Generate number sequences via recurrence.

```python
# Explicit formula
Sequence(lambda i, f: 2*i+1)  # f(i) = 2i + 1

# Recursive definition
Sequence(lambda i, f: f(i-1)+1, [0,1])  # f(i)=f(i-1)+1 with f(0)=0, f(1)=1
Sequence(lambda i, f: f(i-1)+1, {100:101, 102:103})  # Sparse base cases

# Usage
seq = Sequence(lambda i, f: f(i-1)+2, [0,2,4])
seq.get(3)  # Returns 6
seq.get(4,6)  # Returns [8,10,12]
```

Important: Recursive definitions require base cases.

---

Utilities

Conversion:
```python
ati([0, 5, 100, 1E3, 1E5])  # Converts scientific notation to integers
```

Random Numbers:
```python
randint(1,5)  # Integer in [1,5]
uniform(1,5)  # Float in [1,5]
choice([1,2,3])  # Random selection
random()  # Float in [0,1)
```

Constants:
```python
PI  # 3.1415926...
E  # 2.7182818...
ALPHABET_SMALL  # "abcdefghijklmnopqrstuvwxyz"
ALPHABET_CAPITAL  # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALPHABET  # Combined letters
NUMBERS  # "0123456789"
```