Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
added basic demo video maker
Dillon DuPonta37fa708482e
diff --git a/examples/video_maker_traj.py b/examples/video_maker_traj.pynew file mode 100644index 0000000000..34a5ad3c2b--- /dev/null+++ b/examples/video_maker_traj.py@@ -0,0 +1,692 @@+"""+Video Maker for Trajectory Dataset++This script processes a trajectory dataset folder, extracts frames,+and creates an animated video with cursor overlays.+"""++from utils import load_dotenv_files+load_dotenv_files()++import os+import json+import math+import shutil+import re+from pathlib import Path+import argparse+import numpy as np+from PIL import Image, ImageDraw, ImageFilter+import requests+from io import BytesIO+from tqdm import tqdm++# Constants+CURSOR_SCALE = 2 # Scale factor for cursor size+FRAMES_PER_CLICK = 8 # Number of frames to show for click animation+FRAMES_PER_MOVE = 10 # Number of frames to interpolate between cursor positions+CURSOR_NORMAL = "https://mac-cursors.netlify.app/png/[email protected]"+CURSOR_CLICKING = "https://mac-cursors.netlify.app/png/[email protected]"+CURSOR_TYPING = "https://mac-cursors.netlify.app/png/[email protected]"+CURSOR_HOTSPOT = (20, 15)+OUTPUT_DIR = "examples/output/video_frames"++# Vignette effect constants+VIGNETTE_WIDTH = 10 # Width of the vignette border in pixels+VIGNETTE_COLORS = [(128, 0, 255), (0, 0, 255)] # Purple to Blue gradient colors+VIGNETTE_ANIMATION_SPEED = 0.1 # Controls speed of the animation pulse++def download_image(url):+ """Download an image from a URL."""+ response = requests.get(url)+ return Image.open(BytesIO(response.content))++def load_cursor_images():+ """Load and resize cursor images."""+ cursor_normal = download_image(CURSOR_NORMAL)+ cursor_clicking = download_image(CURSOR_CLICKING)+ cursor_typing = download_image(CURSOR_TYPING)++ # Resize all cursors based on CURSOR_SCALE+ width_normal, height_normal = cursor_normal.size+ width_clicking, height_clicking = cursor_clicking.size+ width_typing, height_typing = cursor_typing.size++ cursor_normal = cursor_normal.resize((int(width_normal * CURSOR_SCALE), int(height_normal * CURSOR_SCALE)))+ cursor_clicking = cursor_clicking.resize((int(width_clicking * CURSOR_SCALE), int(height_clicking * CURSOR_SCALE)))+ cursor_typing = cursor_typing.resize((int(width_typing * CURSOR_SCALE), int(height_typing * CURSOR_SCALE)))++ cursors = {+ "normal": cursor_normal,+ "clicking": cursor_clicking,+ "typing": cursor_typing+ }++ return cursors++# Store the last known cursor position and thought across all frames+last_known_cursor_position = None+last_known_thought = None++def extract_thought_from_api_response(filename):+ """Extract thought from API response for the current frame."""+ global last_known_thought++ turn_dir = os.path.dirname(filename)+ api_response_files = [f for f in os.listdir(turn_dir) if f.endswith('_response.json')]++ for api_file in api_response_files:+ try:+ with open(os.path.join(turn_dir, api_file), 'r') as f:+ data = json.load(f)+ # Extract content from response+ content = data.get('response', {}).get('choices', [{}])[0].get('message', {}).get('content', '')++ # Extract the Thought section+ thought_match = re.search(r"Thought: (.*?)(?:\nAction:|$)", content, re.DOTALL)+ if thought_match:+ thought = thought_match.group(1).strip()+ if thought:+ last_known_thought = thought+ return thought+ except (json.JSONDecodeError, FileNotFoundError, KeyError):+ pass++ # Return the last known thought if no new thought is found+ return last_known_thought++def extract_cursor_position_from_filename(filename):+ """Extract cursor position from a filename containing click info."""+ global last_known_cursor_position++ # For 'screenshot_NNN_click_TIMESTAMP.png', try to extract coordinates+ match = re.search(r'click_(\d+)_(\d+)_\d+\.png$', filename)+ if match:+ position = (int(match.group(1)), int(match.group(2)))+ last_known_cursor_position = position+ return position++ # Check if we have position info from API response+ turn_dir = os.path.dirname(filename)+ api_response_files = [f for f in os.listdir(turn_dir) if f.endswith('_response.json')]++ for api_file in api_response_files:+ try:+ with open(os.path.join(turn_dir, api_file), 'r') as f:+ data = json.load(f)+ # Extract action from response+ content = data.get('response', {}).get('choices', [{}])[0].get('message', {}).get('content', '')+ # Look for coordinates in the action+ # First try the pattern from the example: click(start_box='(28,15)')+ coord_match = re.search(r"click\(start_box='\((\d+),(\d+)\)'\)", content)+ if coord_match:+ position = (int(coord_match.group(1)), int(coord_match.group(2)))+ last_known_cursor_position = position+ return position++ # Try alternative pattern: click(start_box='<|box_start|>(x,y)<|box_end|>')+ alt_match = re.search(r"click\(start_box='<\|box_start\|>\((\d+),(\d+)\)<\|box_end\|>'\)", content)+ if alt_match:+ position = (int(alt_match.group(1)), int(alt_match.group(2)))+ last_known_cursor_position = position+ return position+ except (json.JSONDecodeError, FileNotFoundError, KeyError):+ pass++ # No new position found, return the last known position+ return last_known_cursor_position++def extract_action_from_filename(filename):+ """Determine the action type from the filename pattern."""+ if 'click' in filename:+ return "clicking"+ elif 'type' in filename:+ return "typing"+ else:+ return "normal"++def create_animated_vignette(image, frame_index):+ """+ Create an animated purple/blue gradient vignette effect around the border of the image.+ The animation pulses the colors and gently varies their intensity over time.++ Args:+ image: The base image to apply the vignette to+ frame_index: Current frame index for animation timing++ Returns:+ Image with vignette effect applied+ """+ # Create a copy of the image to work with+ result = image.copy()+ width, height = result.size++ # Create a blank RGBA image for the vignette overlay+ vignette = Image.new('RGBA', (width, height), (0, 0, 0, 0))+ draw = ImageDraw.Draw(vignette)++ # Calculate animation phase based on frame index+ phase = math.sin(frame_index * VIGNETTE_ANIMATION_SPEED) * 0.5 + 0.5 # Oscillates between 0 and 1++ # Interpolate between the vignette colors based on the animation phase+ color1 = VIGNETTE_COLORS[0]+ color2 = VIGNETTE_COLORS[1]+ animated_color = (+ int(color1[0] + (color2[0] - color1[0]) * phase),+ int(color1[1] + (color2[1] - color1[1]) * phase),+ int(color1[2] + (color2[2] - color1[2]) * phase),+ )++ # Draw gradient borders around each edge+ # Top border+ for i in range(VIGNETTE_WIDTH):+ alpha = int(150 * (1 - i / VIGNETTE_WIDTH))+ border_color = animated_color[:3] + (alpha,)+ draw.line([(0, i), (width, i)], fill=border_color, width=1)+ draw.line([(0, height-i-1), (width, height-i-1)], fill=border_color, width=1)+ draw.line([(i, 0), (i, height)], fill=border_color, width=1)+ draw.line([(width-i-1, 0), (width-i-1, height)], fill=border_color, width=1)++ # Apply slight blur to smooth the gradient+ vignette = vignette.filter(ImageFilter.GaussianBlur(16))++ # Composite the vignette over the original image+ result = Image.alpha_composite(result.convert('RGBA'), vignette)++ return result.convert('RGB') # Convert back to RGB for consistency++def scale_cursor_with_animation(cursor, frame, max_frames, cursor_type):+ """Create springy scale animation for cursor."""+ if cursor_type == "normal":+ return cursor++ # For clicking or typing cursors, create a spring effect+ progress = frame / max_frames++ # Spring effect calculation - starts big, gets smaller, then back to normal+ if progress < 0.3:+ # Start with larger scale, shrink down+ scale = 1.3 - progress+ elif progress < 0.7:+ # Then bounce back up a bit+ scale = 0.7 + (progress - 0.3) * 0.8+ else:+ # Then settle to normal (1.0)+ scale = 1.0 + (1.0 - progress) * 0.3++ # Apply scale+ width, height = cursor.size+ new_width = int(width * scale)+ new_height = int(height * scale)+ return cursor.resize((new_width, new_height))++# Store the last thought bubble position+last_thought_bubble_pos = None++def draw_thought_bubble(image, position, thought_text, frame_index):+ """Draw a thought bubble with the AI's thoughts near the cursor position."""+ global last_thought_bubble_pos++ if thought_text is None or position is None:+ return image++ # Create a copy of the image to work with+ result = image.copy()++ # Set up text parameters+ font_size = 16+ try:+ # Try to use a nice font if available+ from PIL import ImageFont+ try:+ font = ImageFont.truetype("Arial", font_size)+ except IOError:+ # Fallback to default font+ font = ImageFont.load_default()+ except ImportError:+ font = None++ # Wrap text to fit in bubble+ max_width = 400 # Max width in pixels+ wrapped_lines = []+ words = thought_text.split()+ current_line = []++ for word in words:+ # Add word to current line+ test_line = ' '.join(current_line + [word])++ # Create a temporary draw object to measure text width if needed+ temp_draw = ImageDraw.Draw(Image.new('RGB', (1, 1)))++ # Measure the text width+ if font:+ if hasattr(temp_draw, 'textlength'):+ text_width = temp_draw.textlength(test_line, font=font)+ else:+ # Fall back to rough estimation+ text_width = len(test_line) * (font_size * 0.6)+ else:+ # Rough estimation if no font metrics are available+ text_width = len(test_line) * (font_size * 0.6)++ if text_width <= max_width:+ current_line.append(word)+ else:+ # Line is full, start a new line+ if current_line:+ wrapped_lines.append(' '.join(current_line))+ current_line = [word]++ # Don't forget the last line+ if current_line:+ wrapped_lines.append(' '.join(current_line))++ # Limit number of lines for very long thoughts+ max_lines = 8+ if len(wrapped_lines) > max_lines:+ wrapped_lines = wrapped_lines[:max_lines-1] + ["..."]++ # Calculate text dimensions+ line_height = font_size + 4+ text_height = len(wrapped_lines) * line_height++ # Find the widest line+ if font:+ # Create a draw object to measure text width+ temp_draw = ImageDraw.Draw(Image.new('RGB', (1, 1)))+ if hasattr(temp_draw, 'textlength'):+ text_width = max(temp_draw.textlength(line, font=font) for line in wrapped_lines)+ else:+ # Fall back to rough estimation+ text_width = max(len(line) * (font_size * 0.6) for line in wrapped_lines)+ else:+ text_width = max(len(line) * (font_size * 0.6) for line in wrapped_lines)++ # Add padding+ padding = 20+ bubble_width = text_width + padding * 2+ bubble_height = text_height + padding * 2++ # Calculate bubble position - move slowly towards cursor position+ x, y = position+ screen_width, screen_height = image.size++ # Default initial position if this is the first bubble+ target_bubble_x = min(x + 30, screen_width - bubble_width - 10)+ target_bubble_y = max(y - bubble_height - 30, 10)++ # Ensure target position is fully on screen+ if target_bubble_x < 10:+ target_bubble_x = 10+ if target_bubble_y + bubble_height > screen_height - 10:+ target_bubble_y = screen_height - bubble_height - 10++ # Calculate new position with slow movement towards target+ # Very slow movement factor (0.01 means it moves 1% of the distance per frame)+ movement_factor = 0.001++ if last_thought_bubble_pos is None:+ # First frame, set to target position+ bubble_x, bubble_y = target_bubble_x, target_bubble_y+ else:+ # Interpolate slowly towards target position+ last_x, last_y = last_thought_bubble_pos+ bubble_x = last_x + (target_bubble_x - last_x) * movement_factor+ bubble_y = last_y + (target_bubble_y - last_y) * movement_factor++ # Add a subtle animation effect to the bubble+ # animation_offset = math.sin(frame_index * 0.1) * 2+ # bubble_y += int(animation_offset)++ # Store position for next frame+ last_thought_bubble_pos = (bubble_x, bubble_y)++ # Draw rounded rectangle for bubble+ corner_radius = 15++ # Background with black gaussian blur+ background_color = (0, 0, 0, 180) # Black with transparency+ outline_color = (50, 50, 50, 255) # Dark gray outline++ # Draw the bubble background - first create an RGBA version+ bubble_img = Image.new('RGBA', result.size, (0, 0, 0, 0))+ bubble_draw = ImageDraw.Draw(bubble_img)++ # Draw rounded rectangle+ # Check if rounded_rectangle is available (PIL 8.0.0+)+ if hasattr(bubble_draw, 'rounded_rectangle'):+ bubble_draw.rounded_rectangle(+ [bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],+ radius=corner_radius,+ fill=background_color,+ outline=outline_color,+ width=2+ )+ else:+ # Fall back to regular rectangle if rounded_rectangle not available+ bubble_draw.rectangle(+ [bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],+ fill=background_color,+ outline=outline_color+ )++ # Apply gaussian blur to the bubble background+ bubble_img = bubble_img.filter(ImageFilter.GaussianBlur(3))++ # Draw small triangle pointing to cursor+ pointer_size = 10+ pointer_x = x + 15+ pointer_y = y - 5++ # Make sure pointer is under the bubble+ if pointer_x > bubble_x + bubble_width:+ pointer_x = bubble_x + bubble_width - 20+ elif pointer_x < bubble_x:+ pointer_x = bubble_x + 20++ # Create an overlay for the pointer+ pointer_overlay = Image.new('RGBA', result.size, (0, 0, 0, 0))+ pointer_draw = ImageDraw.Draw(pointer_overlay)++ # Draw pointer triangle+ # pointer_draw.polygon(+ # [+ # (pointer_x, pointer_y),+ # (pointer_x - pointer_size, pointer_y - pointer_size),+ # (pointer_x + pointer_size, pointer_y - pointer_size)+ # ],+ # fill=background_color,+ # outline=outline_color+ # )++ # Apply gaussian blur to the pointer+ pointer_overlay = pointer_overlay.filter(ImageFilter.GaussianBlur(3))++ # Composite the bubble and pointer onto the original image+ result = Image.alpha_composite(result.convert('RGBA'), bubble_img)+ result = Image.alpha_composite(result, pointer_overlay)++ # Now draw the text+ draw = ImageDraw.Draw(result)+ text_x = bubble_x + padding+ text_y = bubble_y + padding++ text_color = (255, 255, 255, 255) # White text+ for line in wrapped_lines:+ draw.text((text_x, text_y), line, font=font, fill=text_color)+ text_y += line_height++ return result.convert('RGB')++def create_cursor_overlay(base_image, position, cursor_images, thought_text=None, cursor_type="normal", animation_frame=0, frame_index=0):+ """Create an image with cursor overlaid on the base image and thought bubble if available."""+ # Create a copy of the base image+ result = base_image.copy()++ # If position is None, return the image without a cursor+ if position is None:+ return result++ # Get the appropriate cursor image+ cursor = cursor_images[cursor_type]++ # Apply animation scaling if needed+ if cursor_type in ["clicking", "typing"]:+ cursor = scale_cursor_with_animation(cursor, animation_frame, FRAMES_PER_CLICK, cursor_type)++ # Calculate position to center the cursor hotspot+ # Cursor hotspot is at (20,15) of the cursor image+ x, y = position+ hotspot_x, hotspot_y = CURSOR_HOTSPOT+ cursor_x = x - (hotspot_x * CURSOR_SCALE) # X offset for hotspot+ cursor_y = y - (hotspot_y * CURSOR_SCALE) # Y offset for hotspot++ # Paste the cursor onto the image+ result.paste(cursor, (int(cursor_x), int(cursor_y)), cursor)++ # Add thought bubble if text is available+ if thought_text:+ result = draw_thought_bubble(result, position, thought_text, frame_index)++ return result++def get_screenshot_files(trajectory_dir):+ """+ Get all screenshot files from a trajectory directory, sorted by sequence number.++ Args:+ trajectory_dir: Path to trajectory directory containing turn_XXX folders++ Returns:+ List of tuples (path, sequence_number, action_type, position)+ """+ screenshot_files = []++ # List all turn directories in order+ turn_dirs = sorted([d for d in os.listdir(trajectory_dir) if d.startswith('turn_')],+ key=lambda x: int(x.split('_')[1]))++ for turn_dir in turn_dirs:+ turn_path = os.path.join(trajectory_dir, turn_dir)+ if not os.path.isdir(turn_path):+ continue++ # Get all screenshot files in this turn+ files = [f for f in os.listdir(turn_path) if f.startswith('screenshot_') and f.endswith('.png')]++ for file in files:+ file_path = os.path.join(turn_path, file)++ # Extract sequence number from filename (e.g., screenshot_003_...)+ seq_match = re.search(r'screenshot_(\d+)', file)+ if seq_match:+ seq_number = int(seq_match.group(1))++ # Determine action type from filename+ action_type = extract_action_from_filename(file)++ # Get cursor position if available+ position = extract_cursor_position_from_filename(file_path)++ screenshot_files.append((file_path, seq_number, action_type, position))++ # Sort by sequence number+ screenshot_files.sort(key=lambda x: x[1])++ return screenshot_files++def process_trajectory(trajectory_dir, output_dir, cursors):+ """Process a trajectory directory and create output frames."""+ # Get all screenshot files+ screenshot_files = get_screenshot_files(trajectory_dir)++ if not screenshot_files:+ print(f"No screenshot files found in {trajectory_dir}")+ return++ # Create output directory+ os.makedirs(output_dir, exist_ok=True)++ # Track frame index+ frame_index = 0++ # Process each screenshot+ prev_img = None+ prev_cursor_pos = None++ for i, (file_path, seq_number, action_type, position) in enumerate(tqdm(screenshot_files, desc="Processing frames")):+ # Load the current image+ try:+ current_img = Image.open(file_path)+ except Exception as e:+ print(f"Error loading image {file_path}: {e}")+ continue++ # Current cursor position+ current_cursor_pos = position++ # Check if the current frame has an action (click/typing)+ is_action_frame = action_type in ["clicking", "typing"]++ if is_action_frame:+ # If we have a previous frame, use it for the first half of animation+ if prev_img is not None:+ half_frames = FRAMES_PER_CLICK // 2+ # First half of animation uses PREVIOUS image+ for j in range(half_frames):+ # Get the thought from the API response+ current_thought = extract_thought_from_api_response(file_path)++ output_img = create_cursor_overlay(+ prev_img, current_cursor_pos, cursors,+ thought_text=current_thought,+ cursor_type=action_type,+ animation_frame=j,+ frame_index=frame_index+ )+ # Apply animated vignette effect+ output_img = create_animated_vignette(output_img, frame_index)+ output_img.save(os.path.join(output_dir, f"frame_{frame_index:04d}.png"))+ frame_index += 1++ # Second half uses CURRENT image+ for j in range(half_frames, FRAMES_PER_CLICK):+ # Get the thought from the API response+ current_thought = extract_thought_from_api_response(file_path)++ output_img = create_cursor_overlay(+ current_img, current_cursor_pos, cursors,+ thought_text=current_thought,+ cursor_type=action_type,+ animation_frame=j,+ frame_index=frame_index+ )+ # Apply animated vignette effect+ output_img = create_animated_vignette(output_img, frame_index)+ output_img.save(os.path.join(output_dir, f"frame_{frame_index:04d}.png"))+ frame_index += 1+ else:+ # If no previous frame, use current for full animation+ for j in range(FRAMES_PER_CLICK):+ # Get the thought from the API response+ current_thought = extract_thought_from_api_response(file_path)++ output_img = create_cursor_overlay(+ current_img, current_cursor_pos, cursors,+ thought_text=current_thought,+ cursor_type=action_type,+ animation_frame=j,+ frame_index=frame_index+ )+ # Apply animated vignette effect+ output_img = create_animated_vignette(output_img, frame_index)+ output_img.save(os.path.join(output_dir, f"frame_{frame_index:04d}.png"))+ frame_index += 1+ else:+ # Regular frame with normal cursor+ # Get the thought from the API response+ current_thought = extract_thought_from_api_response(file_path)++ output_img = create_cursor_overlay(+ current_img, current_cursor_pos, cursors,+ thought_text=current_thought,+ cursor_type="normal",+ frame_index=frame_index+ )+ # Apply animated vignette effect+ output_img = create_animated_vignette(output_img, frame_index)+ output_img.save(os.path.join(output_dir, f"frame_{frame_index:04d}.png"))+ frame_index += 1++ # Add position interpolation frames if we're not at the last frame+ if i < len(screenshot_files) - 1:+ # Get next position+ next_cursor_pos = screenshot_files[i+1][3]++ # Only interpolate if both positions are valid and different+ if current_cursor_pos is not None and next_cursor_pos is not None and current_cursor_pos != next_cursor_pos:+ for j in range(1, FRAMES_PER_MOVE):+ progress = j / FRAMES_PER_MOVE+ interp_x = current_cursor_pos[0] + (next_cursor_pos[0] - current_cursor_pos[0]) * progress+ interp_y = current_cursor_pos[1] + (next_cursor_pos[1] - current_cursor_pos[1]) * progress+ interp_pos = (int(interp_x), int(interp_y))++ # Create interpolated movement frame+ # Get the thought from the API response+ current_thought = extract_thought_from_api_response(file_path)++ output_img = create_cursor_overlay(+ current_img, interp_pos, cursors,+ thought_text=current_thought,+ cursor_type="normal",+ frame_index=frame_index+ )+ # Apply animated vignette effect+ output_img = create_animated_vignette(output_img, frame_index)+ output_img.save(os.path.join(output_dir, f"frame_{frame_index:04d}.png"))+ frame_index += 1++ # Save current frame as previous for next iteration+ prev_img = current_img+ prev_cursor_pos = current_cursor_pos++def main():+ """Main function to process the trajectory and create video frames."""+ parser = argparse.ArgumentParser(description='Create a video from a trajectory folder.')+ parser.add_argument('trajectory_dir', type=str, help='Path to the trajectory folder')+ parser.add_argument('--output_dir', type=str, default=OUTPUT_DIR, help='Output directory for video frames')+ parser.add_argument('--fps', type=int, default=24, help='Frames per second for the output video')+ parser.add_argument('--output_video', type=str, default='output_video.mp4', help='Path to output video file')+ parser.add_argument('--skip_ffmpeg', action='store_true', help='Skip running ffmpeg to create video')+ args = parser.parse_args()++ trajectory_dir = args.trajectory_dir+ output_dir = args.output_dir+ fps = args.fps+ output_video = args.output_video+ skip_ffmpeg = args.skip_ffmpeg++ # Check if trajectory directory exists+ if not os.path.exists(trajectory_dir):+ print(f"Trajectory directory {trajectory_dir} does not exist")+ return++ # Clean output directory if it exists+ if os.path.exists(output_dir):+ shutil.rmtree(output_dir)++ # Create output directory+ os.makedirs(output_dir, exist_ok=True)++ # Load cursor images+ print("Loading cursor images...")+ cursors = load_cursor_images()++ # Process the trajectory+ print(f"Processing trajectory from {trajectory_dir}...")+ process_trajectory(trajectory_dir, output_dir, cursors)++ print(f"Processing complete. Frames saved to {output_dir}")++ # Run ffmpeg to create the video+ if not skip_ffmpeg:+ print(f"Running ffmpeg to create video: {output_video}")+ ffmpeg_cmd = f"ffmpeg -y -framerate {fps} -i {output_dir}/frame_%04d.png -c:v libx264 -pix_fmt yuv420p {output_video}"+ try:+ import subprocess+ result = subprocess.run(ffmpeg_cmd, shell=True, check=True,+ stdout=subprocess.PIPE, stderr=subprocess.PIPE,+ text=True)+ print(f"Video created successfully: {output_video}")+ except subprocess.CalledProcessError as e:+ print(f"Error running ffmpeg: {e}")+ print(f"ffmpeg output:\n{e.stdout}\n{e.stderr}")+ print("\nYou can create a video manually with this command:")+ print(ffmpeg_cmd)+ else:+ print("Skipping ffmpeg. You can create a video from these frames using ffmpeg with this command:")+ print(f"ffmpeg -framerate {fps} -i {output_dir}/frame_%04d.png -c:v libx264 -pix_fmt yuv420p {output_video}")++if __name__ == "__main__":+ main()