Forem: Sarwadnya Mahajan

# Captain Cool — Multi-Agent IPL Match Strategist 🏏

Sarwadnya Mahajan — Sun, 17 May 2026 12:56:05 +0000

When the pressure is at its peak, four AI minds debate so the captain doesn't have to guess.

The Problem

IPL captaincy decisions happen in seconds. Bowl a spinner in the death overs with dew? Persist with a struggling fast bowler who has quota left? Bring in the Impact Player now or save them?

A single AI model gives you one answer. But cricket captaincy isn't about one answer — it's about considering the counter-argument, the risk, the gut instinct, and then making a call you can defend.

Captain Cool simulates this internal debate using four specialized AI agents that argue, challenge, and ultimately produce a decision that has been stress-tested before it's made.

One agent fetches live data. One makes the call like MS Dhoni. One tears it apart like Virat Kohli. One wraps it all in commentary like Harsha Bhogle. The result: a decision that's been through the fire.

Architecture Overview

┌─────────────┐
│  USER INPUT  │  Match state, teams, venue, conditions
└──────┬──────┘
       │
       ▼
┌──────────────┐
│ ORCHESTRATOR │  5-turn debate manager + validation guards
└──────┬───────┘
       │
       ▼ Turn 1
┌──────────────────────────────────────────┐
│        STATS ANALYST (Gemini 2.5 Flash)   │
│  Tools: CricAPI live → ESPN → Fallback    │
│  + win_probability + player_stats         │
│  + venue_profile + bowler_quota           │
│  Output: Structured stats brief           │
└──────────────┬───────────────────────────┘
               │ stats_brief
               ▼ Turn 2
┌──────────────────────────────────────────┐
│        STRATEGIST (Gemini 2.5 Flash)      │
│  Personality: MS Dhoni's brain            │
│  Output: DECISION + FIELD_SETUP +         │
│          REASONING + REVISION_STATUS      │
└──────────────┬───────────────────────────┘
               │ initial_proposal
               ▼ Turn 3
┌──────────────────────────────────────────┐
│     DEVIL'S ADVOCATE (Gemini 2.5 Flash)   │
│  Personality: Virat Kohli's aggression    │
│  Output: CHALLENGE + ALTERNATIVE +        │
│          RISK_IF_WRONG + STAT_BACKING     │
└──────────────┬───────────────────────────┘
               │ devils_challenge
               ▼ Turn 4
┌──────────────────────────────────────────┐
│     STRATEGIST AGAIN (Gemini 2.5 Flash)   │
│  Receives challenge, defends or revises   │
│  Output: Final DECISION + REVISION_STATUS │
└──────────────┬───────────────────────────┘
               │ final_decision
               ▼ Turn 5
┌──────────────────────────────────────────┐
│       COMMENTATOR (Gemini 2.5 Flash)      │
│  Personality: Harsha Bhogle + Shastri     │
│  Output: 150-word broadcast commentary    │
└──────────────┬───────────────────────────┘
               │
               ▼
┌──────────────────────────────────────────┐
│          STREAMLIT UI                     │
│  5 tabs + live banner + debate log        │
└──────────────────────────────────────────┘

Note: Replace this ASCII diagram with an Excalidraw visual before publishing.

Google Tech Stack Used

Technology	Role	Why Chosen
Gemini 2.5 Flash	All 4 agent brains	Fast, cheap, excellent at structured output and cricket reasoning
Google ADK	Tool registration & agent framework	FunctionTool wrapping gives judges visible tool-use in traces
Google AI Studio	Prompt prototyping	Tested each agent's system prompt interactively before coding
Google Antigravity	Build session IDE	Full project built in Antigravity — `.antigravity/` folder proves it
BeautifulSoup4 / Requests	Live Data Backup	Used for the ESPNCricinfo web scraper when API limits are reached

Agent Profiles

1. StatsAnalyst — The Data Machine

Personality: Pure facts. No opinions. Temperature 0.1.

System Prompt:

You are StatsAnalyst — a cricket data specialist for IPL T20 matches.

YOUR ONLY JOB: Process match state data and return a structured stats brief. You are NOT a strategist. You do NOT make decisions. You report facts.

RULES:
1. You must ALWAYS report the data source (live API or hardcoded fallback) and timestamp.
2. If live data is available, use the live score and overs to override manually entered values.
3. Report batter handedness EVERY TIME — it changes field setup completely.
4. Flag any bowler who has bowled 3 or more overs with a BOWLER_QUOTA_ALERT.
5. Give win probability as a SINGLE NUMBER, not a range.
6. NEVER guess any number — only report what the tool results show.
7. Determine the match phase: powerplay (overs 1-6), middle (overs 7-15), death (overs 16-20).

Temperature: 0.1 — Maximum factual accuracy, no creative liberty with numbers.

Input: Match state + live API data + tool results (player stats, venue, win probability)

Output Format:

LIVE_DATA_SOURCE: [source]
FETCHED_AT: [timestamp]
MATCH_PHASE: [phase]
BATTING_WIN_PROB: [X]%
PROJECTED_OR_REQUIRED: [value]
KEY_BATTER: [name] ([hand]-handed) — [stats]
KEY_BOWLER_THREAT: [name] — [reason]
VENUE_FACTOR: [insight]
BOWLER_QUOTA_ALERT: [alert or NONE]
CONFIDENCE: [level] — [reason]

2. Strategist — Captain Cool's Brain

Personality: MS Dhoni. Ice-cold. Data-driven. Never panics. Temperature 0.4.

System Prompt:

You are the Strategist — MS Dhoni's brain. Ice-cold. Data-driven. Never panics. Makes exactly one clear call. Explains it in cricket language, not jargon.

FACTORS YOU MUST CONSIDER:
1. BATTER HANDEDNESS vs BOWLER TYPE MATCHUP
2. BOWLER QUOTA — NEVER suggest a bowler who has already bowled 4 overs
3. PHASE-SPECIFIC LOGIC — Powerplay, middle, and death require different thinking
4. DEW FACTOR — If dew is active, spinners become ineffective after over 14
5. IMPACT PLAYER — When is the right moment
6. FIELD POSITIONS — Name at least 2 specific fielding positions

Temperature: 0.4 — Balanced reasoning, slight creativity for tactical innovation.

Input: Stats brief + match state + optional challenge from DevilsAdvocate

Output Format:

DECISION: [action]
REASONING: [3 sentences max]
CONFIDENCE: [0-100]
FIELD_SETUP: [2-3 positions]
ALTERNATIVE_CONSIDERED: [what else was considered]
REVISION_STATUS: REVISED: YES or REVISED: NO

3. DevilsAdvocate — The Challenger

Personality: Virat Kohli's aggressive instinct. Always pushes back. Temperature 0.7.

System Prompt:

You are the DevilsAdvocate — Virat Kohli's aggressive instinct. Always pushes back. Never fully agrees. Finds the flaw in every plan. Loves to prove the obvious choice is wrong.

RULES:
1. Find at least ONE SPECIFIC weakness
2. Propose a CONCRETE ALTERNATIVE with player names
3. QUANTIFY THE RISK if Strategist is wrong
4. Back challenge with ONE SPECIFIC STAT or venue fact
5. NEVER agree completely
6. Be aggressive but LOGICAL

Temperature: 0.7 — Creative enough to find contrarian angles, grounded enough to stay logical.

Input: Strategist's proposal + stats brief + match state

Output Format:

CHALLENGE: [specific weakness]
ALTERNATIVE: [counter-call with players]
RISK_IF_WRONG: [quantified consequence]
STAT_BACKING: [supporting evidence]

4. Commentator — The Voice

Personality: Harsha Bhogle meets Ravi Shastri. Temperature 0.9.

System Prompt:

You are the Commentator — Harsha Bhogle's eloquence meets Ravi Shastri's passion. Speaks to fans, not to analysts. Every sentence earns its place.

RULES:
1. Use player NICKNAMES (King Kohli, Boom Boom, Captain Cool)
2. Reference VENUE CHARACTER vividly (Dharamshala = mountain fortress, Delhi = furnace)
3. Summarize dissent in one sentence starting with "The dissenting view:"
4. End with one prediction starting with "The call:"
5. MAXIMUM 150 words
6. Sound like a LIVE BROADCAST
7. NEVER use statistics — only narratives

Temperature: 0.9 — Maximum vivid, expressive language for broadcast feel.

Input: Full debate (proposal + challenge + final decision + match state)

Output: 150-word broadcast commentary

The Tools

ADK Tool Registration

Every tool function is wrapped as a google.adk.tools.FunctionTool:

from google.adk.tools import FunctionTool

adk_get_player_stats = FunctionTool(get_player_stats)
adk_win_probability = FunctionTool(win_probability)
adk_get_live_match_data = FunctionTool(get_best_live_data)

Only the StatsAnalyst agent receives tools. The other three agents reason purely on context.

Win Probability — DLS-Based

The tool uses a simplified Duckworth-Lewis-Stern resource table:

Maps wickets lost (0-9) to resources remaining at each over
For 1st innings: projects final score based on resources used vs total
For 2nd innings: compares required run rate to par RR of 9.0, adjusts for wickets in hand
Caps probability between 5% and 95% to avoid overconfidence

# Simplified Win Probability Logic
par_rr = 9.0
required_rr = runs_needed / overs_left
rr_ratio = par_rr / required_rr
base_prob = rr_ratio * 50  # At par RR, 50% chance

# Adjust for wickets in hand
wicket_factor = (10 - wickets) / 10.0
batting_win_prob = base_prob * wicket_factor

Three-Tier Live Data Fetching

This is the key differentiator for the Technical Depth rubric:

CricAPI Live (Primary) — Calls /v1/cricScore and /v1/match_scorecard endpoints for real-time scores
ESPNCricinfo Scrape (Backup) — Fetches and parses the match page if CricAPI quota runs out
Hardcoded Fallback (Safety net) — Pre-loaded IPL 2026 season data ensures the app never crashes

# ESPN Web Scrape Fallback Example
def get_espn_match_data(match_url):
    headers = {"User-Agent": "Mozilla/5.0..."}
    resp = requests.get(match_url, headers=headers)

    # Basic extraction from page content using regex
    score_pattern = re.findall(r'(\d+)/(\d+)\s*\((\d+\.?\d*)\s*ov\)', resp.text)
    if score_pattern:
        runs, wickets, overs = score_pattern[-1]
        return f"{runs}/{wickets}"

The data_source field in every response tells the UI which tier was used, displayed as a color-coded banner.

The Debate Loop — Example

Scenario: PBKS vs RCB, Match 61, Dharamshala. Over 8 ball 1. RCB batting, 72/1. Virat Kohli on strike, Arshdeep Singh bowling.

Turn 1 — StatsAnalyst

LIVE_DATA_SOURCE: hardcoded fallback
FETCHED_AT: N/A
MATCH_PHASE: middle
BATTING_WIN_PROB: 62%
PROJECTED_OR_REQUIRED: projected score 210
KEY_BATTER: Virat Kohli (right-handed) — 484 runs, avg 53.78, century last match vs KKR
KEY_BOWLER_THREAT: Arshdeep Singh — left arm swing, 13 wickets, angles into right-hander
VENUE_FACTOR: Dharamshala flat pitch, 205+ average, spin ineffective
BOWLER_QUOTA_ALERT: NONE
CONFIDENCE: high — set batter on flat pitch with short boundaries

Turn 2 — Strategist (Initial)

DECISION: Bring on Harpreet Brar (left arm spin) to replace Arshdeep Singh for over 9
REASONING: Kohli dominates pace in the middle overs. A left arm spinner changes the angle and forces Kohli to adjust. Arshdeep has 1 over used — save him for the death where his yorkers are gold.
CONFIDENCE: 72
FIELD_SETUP: Deep midwicket for the slog sweep, short fine leg for the sweep, extra cover to cut the drive
ALTERNATIVE_CONSIDERED: Continuing with Arshdeep — rejected because pace on this flat pitch will be dispatched by a set Kohli
REVISION_STATUS: REVISED: NO

Turn 3 — DevilsAdvocate

CHALLENGE: Harpreet Brar is a left arm spinner on a Dharamshala pitch where spin is NOT effective. Both matches this season went 200+ with spinners being toothless. Kohli's strike rate against left arm spin in the middle overs is elite.
ALTERNATIVE: Keep Lockie Ferguson on — his raw pace and bounce can surprise Kohli. Ferguson generates extra bounce at altitude which is harder to time.
RISK_IF_WRONG: Brar could leak 12-15 runs in the over on this flat pitch, pushing RCB's projected score past 220. That's a game-losing over.
STAT_BACKING: Dharamshala average score is 205+ and spin has been ineffective in both matches this season.

Turn 4 — Strategist (Revised)

DECISION: Bring on Lockie Ferguson for over 9 instead of Harpreet Brar — use pace and bounce to challenge Kohli
REASONING: The Devil's Advocate is right — spin is toothless at Dharamshala this season. Ferguson's extra bounce at altitude creates a genuine challenge even for a set Kohli. His pace makes timing harder on a quick outfield.
CONFIDENCE: 78
FIELD_SETUP: Deep square leg for the pull, fine leg back for the glance, point in a catching position
ALTERNATIVE_CONSIDERED: Harpreet Brar — rejected after Devil's Advocate correctly identified spin's ineffectiveness at this venue
REVISION_STATUS: REVISED: YES

Turn 5 — Commentator

High above the clouds in this mountain fortress, King Kohli is in his kingdom. Seventy-two on the board, just one down, and the maestro is painting the Dharamshala canvas with those trademark drives.

The captain had an idea — slow it down with Harpreet Brar's left arm spin. The dissenting view: "Spin at Dharamshala? Both matches here went past 200 with spinners getting carted — you need Ferguson's thunderbolts."

And the captain listened. Lockie Ferguson gets the ball. Raw pace. Extra bounce. The altitude factor.

The call: Ferguson's express pace will test even Kohli's impeccable timing, and PBKS will keep this under 200 if they strike in the next three overs.

Live Demo Screenshots

TODO: Add screenshots of all 5 tabs and the live data banner before publishing.

[ ] Stats Brief tab with LIVE_DATA_SOURCE visible
[ ] Initial Proposal tab
[ ] Devil's Advocate tab
[ ] Final Decision tab with revision badge
[ ] Commentary tab
[ ] Live data banner (green/yellow)
[ ] Debate Log expander

AI Studio Prompt Links

TODO: Prototype each system prompt in aistudio.google.com, save as shareable link, paste below.

[ ] StatsAnalyst prompt: [link]
[ ] Strategist prompt: [link]
[ ] DevilsAdvocate prompt: [link]
[ ] Commentator prompt: [link]

What I Would Build With More Time

Voice Input via Web Speech API + Gemini Live — Captain speaks the match state, Gemini Live processes it in real-time
Real-time Cricbuzz URL Scraping — Using Gemini's URL context tool for richer live data
Gemini Context Caching Across Overs — Cheap multi-turn memory so the system remembers what happened 3 overs ago
Confidence Score with Counterfactual Analysis — "If we had bowled Ferguson instead of Brar, the projected score would have been..."
Veo Highlight Clip Generation — Generate a short AI video clip visualizing the captain's decision moment

GitHub Repository

[https://github.com/SarwadnyaMahajan/captain-cool]

Built with Google Gemini 2.5 Flash · Google ADK · GDG Cloud Pune APL 2026

#gdgcloudpune

WhisperVoice: Hide Secret Messages Inside Natural Voice Notes

Sarwadnya Mahajan — Sat, 19 Jul 2025 17:09:54 +0000

WhisperVoice: Hide Secret Messages Inside Natural Voice Notes

🔐 Project Overview

WhisperVoice is a cutting-edge project designed to revolutionize secure and covert communication. It offers a novel way to embed secret messages within innocuous, AI-generated voice notes, making the communication both encrypted and invisible.

By blending steganography, encryption, and AI voice synthesis, WhisperVoice enables “hidden in plain sight” messaging—virtually undetectable to unauthorized parties.

The project is available through a powerful platform:

🧩 WhisperVoice Chrome Extension: A seamless browser tool to both encrypt and decrypt voice-based secret messages.

Check this out here: https://frolicking-nasturtium-7cef81.netlify.app/

🎯 Problem Solved

In a surveillance-heavy digital environment, traditional encryption protects content but signals its sensitivity. WhisperVoice addresses this by:

✅ Achieving True Covertness: Secret text is embedded into voice notes using AI-generated acrostic sentences—making them sound perfectly normal.

🛡️ Bypassing Surveillance & Detection: Messages resemble ordinary voice notes, avoiding suspicion even under monitoring.

🧠 Simplifying Advanced Security: Wraps complex cryptography and steganography into a user-friendly experience.

🔒 Ensuring End-to-End Privacy: Full confidentiality from encryption to reveal.

🔁 Offering Flexible Access: Via website or extension—whichever fits the user's need.

💡 Solution Approach

The WhisperVoice system orchestrates a multi-stage process, seamlessly integrating AI and cryptographic techniques across its platforms:

🔐 Encryption Workflow:

API Key Configuration: Users configure their Google Gemini API Key (for AI text generation) and Murf.ai API Key (for voice synthesis). These are securely stored locally.
Secret Message & Security Key Input: The user enters their secret message and a shared keyword (passcode for the cryptographic algorithm).
Cryptographic Transformation (Playfair Cipher):
- The secret message undergoes cryptographic transformation using the Playfair Cipher algorithm with the provided keyword.
- This involves cleaning the message, pairing letters, and applying encryption rules to generate a ciphertext.
- This entire step occurs client-side, ensuring the raw secret message never leaves the user's device.
AI Cover Sentence Generation (Google Gemini API):
- A prompt is sent to the Google Gemini API, instructing it to generate a natural-sounding coverSentence where the first letter of each word exactly matches the ciphertext.
Voice Synthesis (Murf.ai API):
- The coverSentence is sent to the Murf.ai API along with a default voice ID. Murf.ai converts the text into an audio file, providing an audio URL.
Audio Download: The generated audio file is downloaded as an MP3, ready to be shared via any messaging platform.

🔓 Decryption Workflow:

Audio Upload: Users upload the received covert voice note via a floating button and an intuitive drag-and-drop modal.
Passcode Input: The recipient enters the same keyword (passcode) that was used for encryption.
Audio Processing (via Background Service Worker): The audio file is uploaded to AssemblyAI's API for transcription. This is handled by a dedicated background service worker for efficient processing.
Speech-to-Text (AssemblyAI API): AssemblyAI transcribes the audio file into transcribedText.
Ciphertext Extraction: A specialized function processes the transcribedText to extract the first letter of each word, reconstructing the original ciphertext.
Cryptographic Revelation (Playfair Cipher): A Playfair Cipher implementation uses the provided keyword to decrypt the ciphertext back into the original decryptedMessage.
Text-to-Speech (Murf.ai API): The decryptedMessage is sent to the Murf.ai API to convert it into an audio file, allowing the recipient to hear the secret message.
Results Display & Playback: The decryptedMessage is prominently displayed in a results modal, with options to play the synthesized audio or download it. Detailed process steps are also shown for transparency.

📽️ Demo

Live Site: https://frolicking-nasturtium-7cef81.netlify.app/

Demo Video: https://drive.google.com/file/d/1tJDuuP2rJ6eDP9-SIlYepvk-WvIeAMRe/view?usp=sharing

Code Repository: https://github.com/SarwadnyaMahajan/WhisperVoice

🎧 How I Used Murf API

Murf.ai played a pivotal role in bringing the "voice" to WhisperVoice, serving as the bridge between text and natural-sounding audio. Its high-quality Text-to-Speech (TTS) capabilities were essential for both the encryption and decryption phases of our covert communication system.

Key Use Cases:

For Encryption (Creating the Covert Voice Note):

After the secret message is encrypted and the AI generates a coverSentence (whose first letters subtly embed the ciphertext), Murf.ai is used to transform this coverSentence into an audio file.
This is crucial because the entire premise of WhisperVoice relies on the generated audio sounding completely natural and innocuous, effectively "hiding" the secret message in plain sight.
Murf.ai's diverse and realistic voice options ensure that the cover message doesn't sound robotic or suspicious, which would defeat the purpose of covertness.
The API call involves sending the coverSentence and a specified voiceId (e.g., "en-US-natalie") to Murf.ai's /v1/speech/generate endpoint. The returned audio URL is then used to download the final MP3 file for sharing.

For Decryption (Revealing the Secret Message in Audio):

Once the received audio is transcribed by AssemblyAI and the hidden ciphertext is decrypted back into the decryptedMessage, Murf.ai is used again.
This time, it converts the actual decrypted secret message into an audio format. This allows the recipient to not only read the secret message but also to hear it, providing an additional layer of accessibility and confirmation.
This step ensures that the full cycle of voice-based communication is maintained, from a seemingly normal voice note to a clear, audible secret message. The same /v1/speech/generate endpoint is used, but with the decryptedMessage as the input text.

Technical Implementation Details:

API Integration: Murf.ai's API was integrated via fetch requests in our JavaScript code, specifically within the background service worker of the Chrome Extension (and would be similarly handled in a web application's backend or client-side if appropriate).
Authentication: API key authentication was handled by including the api-key in the request headers, as per Murf.ai's documentation.
Voice Selection: We utilized a specific voiceId (e.g., "en-US-natalie") to ensure consistency and quality in the generated speech.
Error Handling: Robust error handling was implemented to catch issues like invalid API keys, rate limits, or problems during speech generation, providing clear feedback to the user.

By leveraging Murf.ai, WhisperVoice achieves its core promise: transforming text into high-quality, natural-sounding speech that is integral to both concealing and revealing secret messages.

🌍 Use Case & Impact

WhisperVoice transcends a mere technical demonstration; it addresses a critical need for enhanced privacy and covert communication in an increasingly transparent digital world. Its real-world applications are diverse, benefiting individuals and organizations across various sectors.

Who Would Benefit from This?

Journalists & Whistleblowers: In environments where traditional encrypted communication might draw unwanted attention or be actively monitored, WhisperVoice offers a discreet channel to share sensitive information without raising red flags.
Activists & Human Rights Defenders: For those operating under oppressive regimes or in high-risk areas, the ability to communicate secretly without appearing to do so is invaluable for organizing, sharing evidence, and ensuring safety.
Privacy-Conscious Individuals: Anyone concerned about their digital footprint and the pervasive surveillance of online communications can use WhisperVoice for personal conversations they wish to keep truly private, even from sophisticated data analysis.
Law Enforcement & Intelligence (Ethical Use): In specific, legally sanctioned scenarios, WhisperVoice could provide a tool for discreet information exchange where overt communication methods are compromised or too risky.
Businesses with Sensitive Communications: While not a replacement for enterprise-grade security, for certain highly sensitive internal discussions or preliminary outreach where discretion is paramount, WhisperVoice offers an additional layer of covertness.
Educators & Researchers: As a pedagogical tool, it can demonstrate advanced concepts in steganography, cryptography, and AI, making complex topics tangible and engaging.

How Does It Improve Existing Processes?

Enhanced Covertness Beyond Encryption: Traditional encryption protects the content of a message but often reveals the act of encryption. WhisperVoice improves upon this by adding a layer of steganography, making the communication appear entirely innocuous. This is a significant leap for scenarios where the very act of secure communication is a risk. It moves beyond simply securing data to securing the intent of communication.
Bypassing Detection & Surveillance: Many surveillance systems flag encrypted traffic or unusual communication patterns. By embedding messages within standard voice notes, WhisperVoice helps users blend into normal digital noise, making their covert communications harder to detect and analyze by automated systems. It offers a potential workaround for communication channels that might be compromised or under active monitoring, as the "carrier" (a voice note) is common and seemingly harmless.
Accessibility of Advanced Techniques: Steganography and advanced cryptography are often complex and require specialized knowledge. WhisperVoice abstracts these complexities behind user-friendly interfaces (both web and extension), making these powerful tools accessible to a broader audience without requiring deep technical expertise. This democratizes access to sophisticated privacy-enhancing technologies.
Versatility Across Platforms: By providing a Chrome Extension, WhisperVoice offers flexibility. The extension provides seamless, integrated functionality directly within the user's browsing environment, making it convenient for regular use. The ability to send the covert voice note through any standard messaging platform (WhatsApp, Telegram, Email, etc.) means users are not tied to a specific secure messaging app, further enhancing its covert nature.
Educational Value: Beyond its practical applications, WhisperVoice serves as an excellent educational tool. It vividly demonstrates the principles of steganography (hiding information), cryptography (securing information), and the practical application of AI in creative problem-solving (generating contextually relevant cover messages).

👥 Team

Team Name: Vocalz

Team Members:

Sarwadnya Mahajan @sarwadnya_mahajan
Harshada Ghanwat @harshada_ghanwat

🔗 Links

🔐 Website: https://frolicking-nasturtium-7cef81.netlify.app/
💻 GitHub Repo: https://github.com/SarwadnyaMahajan/WhisperVoice
🎥 Demo Video: https://drive.google.com/file/d/1tJDuuP2rJ6eDP9-SIlYepvk-WvIeAMRe/view?usp=sharing