Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class BenzeneStructureScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Introduce scene topic
        # 2. Benzene ring diagram (Lines + Circle) - .shift(LEFT * 2.5) - Visual focus left side
        # 3. Molecular formula and explanation text - Text + MathTex - .shift(RIGHT * 2.5) - Content right side
        # 4. Resonance notation (circle inside hexagon) explanation - Text - .shift(DOWN * 1.5) - Secondary text lower center
        # 5. Transition text - Text - .shift(DOWN * 1.5) - Secondary text lower center

        # Colors used: BLUE, RED, GREEN, YELLOW, WHITE

        # 1. Title
        title = Text("Basic Structure and Notation of the Benzene Ring", color=WHITE).to_edge(UP, buff=0.5)

        # 2. Benzene ring diagram with alternating single/double bonds labeled
        # Construct hexagon points
        import numpy as np
        radius = 1.5
        angles = np.linspace(0, 2 * np.pi, 7)[:-1]  # 6 points around circle
        points = [np.array([radius * np.cos(a), radius * np.sin(a), 0]) for a in angles]

        # Lines for hexagon edges with alternating single/double bonds
        edges = VGroup()
        bond_labels = VGroup()
        for i in range(6):
            start = points[i]
            end = points[(i + 1) % 6]
            line = Line(start, end, color=WHITE)
            edges.add(line)
            # Label bonds: even edges double bond (RED), odd edges single bond (BLUE)
            mid = (start + end) / 2
            if i % 2 == 0:
                label = Text("=", font_size=24, color=RED).move_to(mid)
            else:
                label = Text("-", font_size=24, color=BLUE).move_to(mid)
            bond_labels.add(label)

        hexagon = VGroup(edges, bond_labels).shift(LEFT * 2.5)

        # 3. Molecular formula and explanation text on right side
        formula = MathTex("C_6H_6", color=YELLOW).shift(RIGHT * 2.5 + UP * 0.5)
        explanation1 = Text(
            "Benzene is a six-carbon cyclic molecule\n"
            "with alternating single and double bonds.",
            font_size=24, color=WHITE
        ).next_to(formula, DOWN, buff=0.3).shift(RIGHT * 2.5)

        # 4. Resonance explanation text lower center
        resonance_text = Text(
            "Resonance: electrons are delocalized,\n"
            "represented by a circle inside the hexagon.",
            font_size=24, color=GREEN
        ).shift(DOWN * 1.5)

        # Circle inside hexagon to denote delocalized electrons
        circle = Circle(radius=radius * 0.6, color=GREEN).shift(LEFT * 2.5)

        # 5. Transition text lower center (will replace resonance_text)
        transition_text = Text(
            "Next: Mathematical representation of resonance\n"
            "and electron delocalization in benzene.",
            font_size=24, color=WHITE
        ).shift(DOWN * 1.5)

        # Animation Sequence:

        # Step 1: Write title
        self.play(Write(title), run_time=2)

        # Step 2: Show benzene ring diagram with bonds and formula + explanation
        self.play(
            Create(edges), Write(bond_labels),
            FadeIn(formula), Write(explanation1),
            run_time=3
        )

        # Step 3: Show resonance circle and explanation text, fade out bond labels and explanation1
        self.play(
            Create(circle),
            Write(resonance_text),
            FadeOut(bond_labels),
            FadeOut(explanation1),
            run_time=3
        )

        # Step 4: Transition text, fade out resonance_text and circle, keep title and formula visible
        self.play(
            FadeOut(resonance_text),
            FadeOut(circle),
            Write(transition_text),
            run_time=3
        )

        # Final cleanup: fade out all except title and formula
        self.play(
            FadeOut(edges),
            FadeOut(transition_text),
            FadeOut(formula),
            FadeOut(title),
            run_time=2
        )
```

PATTERN: step_progression

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Step equations positioned vertically
        step1 = MathTex(r"{step1}").shift(UP * 2)
        step2 = MathTex(r"{step2}").shift(UP * 0.5)  
        step3 = MathTex(r"{step3}").shift(DOWN * 1)
        
        # Step labels on the right
        label1 = Text("{label1}").scale(0.5).shift(RIGHT * 4 + UP * 2)
        label2 = Text("{label2}").scale(0.5).shift(RIGHT * 4 + UP * 0.5)
        label3 = Text("{label3}").scale(0.5).shift(RIGHT * 4 + DOWN * 1)
        
        # Progressive revelation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(step1))
        self.wait(1)
        self.play(Write(label1))
        self.wait(1)
        self.play(Write(step2))
        self.wait(1)
        self.play(Write(label2))
        self.wait(1)
        self.play(Write(step3))
        self.wait(1)
        self.play(Write(label3))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code: