jiahuimbzuai/CoQuIR huggingface dataset:
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
  if(input[0]<=5) console.log(0)
  else if(input[0]<13) console.log(input[1]/2)
  else console.log(input[1])
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.split(" ");
  var A = parseInt(input[0]);
  var B = parseInt(input[1]);
  var result;

  if(13<=A && A<=100) {
    result = B;
  } else if (6<=A && A<=12){
    result = B/2;           
  } else if (0<=A && A<=5) {
    result = 0;
  }
	
  console.log(result);
}


Main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
function main(input) {
  var age = Number(input.split(' ')[0]);
  var price = Number(input.split(' ')[1]);
  if (age <= 5) {
    console.log(0);
  } else if (age <= 12) {
    console.log(price / 2);
  } else {
    console.log(price);
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
    const args = input.split(' ');
    const a = parseInt(args[0], 10);
    const b = parseInt(args[1], 10);
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
  if(input[0]<5) console.log(0)
  else if(input[0]<12) console.log(input[1]/2)
  else console.log(input[1])
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.trim()
  input = input.split(" ").map(Number);
  if(input[0]<5) console.log(0)
  else if(input[0]<13) console.log(input[1]/2)
  else console.log(input[1])
}Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
  "fmt"
)

func main() {
  var a, b int
  fmt.Scan(&a, &b)
  if a > 12 {
    fmt.Println(b)
  } else if a > 5 {
    fmt.Println(b / 2)
  } else {
    fmt.Println(0)
  }
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Split(bufio.ScanWords)
	log.SetFlags(log.Lshortfile)
	a := nextInt()
	b := nextInt()
	ans := -1
	if a >= 13 {
		ans = b
	} else if a >= 6 && a <= 12 {
		ans = b / 2
	} else {
		ans = 0
	}
	fmt.Println(ans)
}

func nextString() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, err := strconv.Atoi(sc.Text())
	if err != nil {
		panic(err)
	}
	return i
}

var dy = []int{0, 1, 0, -1}
var dx = []int{1, 0, -1, 0}
var MAX = math.MaxInt32

func pow(a, b int) int {
	return int(math.Pow(float64(a), float64(b)))
}

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}
func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	for b != 0 {
		a, b = b, a%b
	}
	return a
}
func max(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}
func min(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r > a[i] {
			r = a[i]
		}
	}
	return r
}
func sum(a []int) (r int) {
	for i := range a {
		r += a[i]
	}
	return r
}
func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

type Pair struct {
	a, b int
}

type Pairs []Pair

func (p Pairs) Len() int {
	return len(p)
}
func (p Pairs) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p Pairs) Less(i, j int) bool {
	if p[i].a == p[j].a {
		return p[i].b < p[j].b
	}
	return p[i].a < p[j].a
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	switch {
	case a <= 5:
		fmt.Println(0)
	case a <= 12:
		fmt.Println(b / 2)
	default:
		fmt.Println(b)
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scan_init()
	a := scanInt()
	b := scanInt()
	if 6 <= a &&  a <= 12 {
		fmt.Println(b/2)
	} else {
		if 5 <= a {
			fmt.Println(0)
		} else {
			fmt.Println(b)
		}
	}
}

var sc = bufio.NewScanner(os.Stdin)

func scan_init() {
	sc.Split(bufio.ScanWords)
}
func scanInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}
func scan() string {
	sc.Scan()
	return sc.Text()
}

var rdr = bufio.NewReaderSize(os.Stdin, 200000)

func readLine() string {
	buf := make([]byte, 0, 200000)
	for {
		l, p, e := rdr.ReadLine()
		if e != nil {
			panic(e)
		}
		buf = append(buf, l...)
		if !p {
			break
		}
	}
	return string(buf)
}
func readLineToNumber() int {
	S := readLine()
	number, _ := strconv.Atoi(S)
	return number
}
func readLineToSlice() []string {
	S := readLine()
	list := strings.Split(S, "")
	return list
}
func readLineToNumberSlice(memo map[string]int) []int {
	// err時は-1を代入
	S := readLine()
	intList := make([]int, len(S))
	for i := 0; i < len(S); i++ {
		if val, ok := memo[string(S[i])]; ok {
			intList[i] = val
		} else {
			intList[i] = -1
		}
	}
	return intList
}
//  [go]
package main

import (
  "fmt"
  "strings"
)

func main() {
  var a, b int
  fmt.Scanf("%d %d", &a, &b)
  
  ans := b
  if a < 13 {
    ans = b / 2
  }
  if a < 5 {
    ans = 0
  }
  fmt.Printf("%d\n", ans)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scan(&a, &b)
	switch {
	case a >= 13:
		fmt.Println(b)
	case 6 <= a || a <= 12:
		fmt.Println(b / 2)
	default:
		fmt.Println(0)
	}
}
//  [ruby]
#
# File    : A.rb
# Author  : Kazune Takahashi
# Created : 2019-5-25 20:54:47
# Powered by Visual Studio Code
#

a, b = gets.chomp.split(" ").map{|i| i.to_i}
if a <= 5
  puts 0
elsif a <= 12
  puts b/2
else
  puts b
end
//  [ruby]
a,b=gets.split.map(&:to_i)
if a>= 13
  puts b
elsif a>=6
  puts b/2
else
  puts 0
end
//  [ruby]
line = $stdin.gets.split.map{|v| v.to_i }
A = line[0]
B = line[1]

if A >= 13 then
  puts B
elsif A >= 6 then
  puts B / 2
elsif A 
  puts 0
end
//  [ruby]
A, B = gets.chomp.split.map(&:to_i)
if A >= 13
  puts B
elsif 6 <= A <= 12
  puts B / 2
else
  puts 0
end
//  [ruby]
a = gets.to_i
b = gets.to_i

if a <= 5
    p 0
  elsif a <= 12
    p b/2
  else
    p b
end
//  [ruby]
a = gets.to_i
b = gets.to_i

case a
  when 0..5
    puts 0
  when 6..12
    puts b / 2
  else
    puts b
end
//  [rust]
fn main() {
    let mut buf= String::new();
    std::io::stdin().read_line(&mut buf).ok();
    
    let mut line_itr = buf.split_whitespace();
    let a: u8 = line_itr.next().unwrap().parse().unwrap();
    let b: u16 = line_itr.next().unwrap().parse().unwrap();
    
    println!("{}",
        if a > 12 {
            b
        } else if a > 5 {
            b / 2
        } else {
            0
        }
    )
    
}
//  [rust]
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}



use std::cmp;
use std::iter::Iterator;

fn main() {
    input! {
        a:usize,
        b:usize,
    }

    if a >= 13{
        println!("{}", b)
    }else if a <= 5{
        println!("{}", "0")
    }else{
        println!("{}", b /2)
    }

}
//  [rust]
fn main() {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).ok();
    let mut it = input.trim().split_whitespace();
    let a:u16 = it.next().unwrap().parse().unwrap();
    let b:u16 = it.next().unwrap().parse().unwrap();
    let result = match a {
        e if e < 6 => 0,
        e if e < 13 => b / 2,
        _ => b
    };
    println!("{}",result);
}
//  [rust]
use std::cmp::*;
use std::collections::*;
use std::io::*;
use std::str::FromStr;
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
fn main(){
    let a:usize = read();
    let b:usize = read();
    println!("{}",if a <= 5{
        0
    }else if 5 < a && 13 < a{
        b / 2
    }else{
        b
    });
}
//  [rust]
#![allow(unused_imports)]

use proconio::{input, fastout};
use proconio::marker::*;

#[fastout]
fn main() {
    input! {
    a: usize,
    b: usize
    }
    let c = if a <= 5 { 0 } else if a > 13
    { b } else { b / 2 };
    println!("{}", c)
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

use std::io::*;
use std::str::FromStr;

macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn readu() -> usize {
    read::<usize>()
}

fn readi() -> i32 {
    read::<i32>()
}

fn main () {
    let a = readu();
    let b = readu();

    if a >= 13 {
        println!("{}", b);
    } else if a >= 12 {
        println!("{}", b / 2);
    } else {
        println!("{}", 0);
    }
}
//  [swift]
func readInts() -> [Int] {
    return readLine()!.split(separator: " ").map { Int($0)! }
}

func main() {
    let ab = readInts()
    let a = ab[0]
    let b = ab[1]
    
    if a >= 13 {
        print(b)
    } else if a >= 6 {
        print(b / 2)
    } else {
        print("0")
    }
}

main()
//  [swift]
let input = readLine()!.split(separator: " ").map { Int($0)! }

let A = input[0]
let B = input[1]

if A >= 13 {
  print(B)
} else if A >= 6 {
  print(B / 2)
} else {
  print(0)
}
//  [swift]
import Foundation
 
let input_line = readLine()!
 
let split = input_line.componentsSeparatedByString(" ") //components(separatedBy:)と実質同じ
let age = Int(split[0])!
let price = Int(split[1])!
var returnPrice = 0

if age > 12 {
	returnPrice = price  
} else if 6 <= age && age <= 12 {
  	returnPrice = price / 2
}
 
print(returnPrice)
//  [swift]
var A=Int(readLine()!)!
var B=Int(readLine()!)!
if A <= 5
print("0")
else if A >= 13
print(B)
else
print(B/2)
//  [swift]
//あってるか分からないけどひとまずテスト

import Foundation

var input_lines = [String]()
let row = 2
for i in 0..<row {
    input_lines.append(readLine()!)
}

let a = Int(input_lines[0])!
let b = Int(input_lines[1])!
//let a = Int(split[0])!
//let b = Int(split[1])!

if a >= 13{
    print(b)
}else if a < 13 && a >= 6{
    print(b/2)
}else{
    print("0")
}
//  [swift]
import Foundation

extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
}

// main
let ab = readIntSplit(by: " ")
var (a, b, ans) = (ab[0], ab[1], 0)
if 5 < a && a <= 12 {
    ans = b/2
} else if 12 < a {
    ans = b
}
print(ans)
//  [typescript]
((input: string): void => {
    const [a, b] = input.split(" ").map(Number);
    console.log(a>=13 ? b : (a>=6 ? b/2 : 0));
})(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from 'fs';

const main = (inp: string) => {

    const [a, b]: number[] = inp.split(' ').map(Number);

    // 13才以上B円
    // 6才以上12才以下半額
    // 5才以下無料
    if (a >= 13) {
        console.log(b);
    } else if(a >=6 && a <=12 ) {
        console.log(b/2);
    } else {
        console.log(0);
    }

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
const input = require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);
const nin=()=>{const r = input[0];input.shift();return Number(r)};
const nrin=(n)=>{const a=[];rep(n,()=>a.push(nin()));return a};
const sin=()=>{const r = input[0];input.shift();return String(r);}
const out = (...a) => {console.log(...a);}
const min = (...a) => {return Math.min(...a);}
const rep = (n, callback) => {for(let i = 0;i < n; i++){callback();}}

const main = () => {
  let [a,b] = [...nrin(2)];
  if(a >= 13) out(b)
  else if(a >= 6) out(b/2)
  else out(0);
}
main();
//  [typescript]
const main = (input: string) => {
  let [r, D, x] = input.trim().split(" ").map(str => parseInt(str))
  const OUTPUT_LINE = 10;
  let answer: string = "";
 
  for (let i = 0; i < OUTPUT_LINE; i++) {
    answer = `${answer}${r * x - D}\n`;
    x = r * x - D
  }
 
  console.log(answer.trim());
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const main = (input: string) => {
  let [r, D, x] = input.trim().split(" ").map(str => parseInt(str))
  const OUTPUT_LINE = 10;
  let answer: string = "";

  for (let i = 0; i < OUTPUT_LINE; i++) {
    answer = `${answer}${r * x - D}\n`;
    x = r * x - D
  }

  console.log(answer.trim());
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const input = require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);
const nin=()=>{const r = input[0];input.shift();return Number(r);}
const sin=()=>{const r = input[0];input.shift();return String(r);}
const out = (...a) => {console.log(...a);}
const rep = (n, callback) => {for(let i = 0;i < n; i++){callback();}}

const main = () => {
  let [n, i, p, before] = [0, 0, 0, -1];
  const a = [];
  const b = [];
  const c = [];
  n = nin();
  rep(n, ()=>a.push(nin()));
  rep(n, ()=>b.push(nin()));
  rep(n-1, ()=>c.push(nin()));
  for(i=0;i<n;i++){
    a[i]-=1;
    p += b[a[i]];
    if(a[i] == before + 1 && before != -1) p+= c[before];
    before = a[i];
  }
  out(p);
}
main();
//  [python]
import math

N = int(input())

def gcd(a, b):
    while b: a, b = b, a % b
    return a

def isPrimeMR(n):
    d = n - 1
    d = d // (d & -d)
    L = [2]
    for a in L:
        t = d
        y = pow(a, t, n)
        if y == 1: continue
        while y != n - 1:
            y = (y * y) % n
            if y == 1 or t == n - 1: return 0
            t <<= 1
    return 1

def findFactorRho(n):
    m = 1 << n.bit_length() // 8
    for c in range(1, 99):
        f = lambda x: (x * x + c) % n
        y, r, q, g = 2, 1, 1, 1
        while g == 1:
            x = y
            for i in range(r):
                y = f(y)
            k = 0
            while k < r and g == 1:
                ys = y
                for i in range(min(m, r - k)):
                    y = f(y)
                    q = q * abs(x - y) % n
                g = gcd(q, n)
                k += m
            r <<= 1
        if g == n:
            g = 1
            while g == 1:
                ys = f(ys)
                g = gcd(abs(x - ys), n)
        if g < n:
            if isPrimeMR(g): return g
            elif isPrimeMR(n // g): return n // g
            return findFactorRho(g)

def primeFactor(n):
    i = 2
    ret = {}
    rhoFlg = 0
    while i*i <= n:
        k = 0
        while n % i == 0:
            n //= i
            k += 1
        if k: ret[i] = k
        i += 1 + i % 2
        if i == 101 and n >= 2 ** 20:
            while n > 1:
                if isPrimeMR(n):
                    ret[n], n = 1, 1
                else:
                    rhoFlg = 1
                    j = findFactorRho(n)
                    k = 0
                    while n % j == 0:
                        n //= j
                        k += 1
                    ret[j] = k

    if n > 1: ret[n] = 1
    if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
    return ret

pfacts = primeFactor(N)
ans = 0
for p, e in pfacts.items():
    i = math.floor((-1 + math.sqrt(1 + 8 * e)) / 2)
    ans += i
print(ans)
//  [python]
def gcd(a, b):
    while b: a, b = b, a % b
    return a
def isPrimeMR(n):
    d = n - 1
    d = d // (d & -d)
    L = [2, 7, 61] if n < 1<<32 else [2, 3, 5, 7, 11, 13, 17] if n < 1<<48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
    for a in L:
        t = d
        y = pow(a, t, n)
        if y == 1: continue
        while y != n - 1:
            y = y * y % n
            if y == 1 or t == n - 1: return 0
            t <<= 1
    return 1
def findFactorRho(n):
    m = 1 << n.bit_length() // 8
    for c in range(1, 99):
        f = lambda x: (x * x + c) % n
        y, r, q, g = 2, 1, 1, 1
        while g == 1:
            x = y
            for i in range(r):
                y = f(y)
            k = 0
            while k < r and g == 1:
                ys = y
                for i in range(min(m, r - k)):
                    y = f(y)
                    q = q * abs(x - y) % n
                g = gcd(q, n)
                k += m
            r <<= 1
        if g == n:
            g = 1
            while g == 1:
                ys = f(ys)
                g = gcd(abs(x - ys), n)
        if g < n:
            if isPrimeMR(g): return g
            elif isPrimeMR(n // g): return n // g
            return findFactorRho(g)
def primeFactor(n):
    i = 2
    ret = {}
    rhoFlg = 0
    while i * i <= n:
        k = 0
        while n % i == 0:
            n //= i
            k += 1
        if k: ret[i] = k
        i += i % 2 + (3 if i % 3 == 1 else 1)
        if i == 101 and n >= 2 ** 20:
            while n > 1:
                if isPrimeMR(n):
                    ret[n], n = 1, 1
                else:
                    rhoFlg = 1
                    j = findFactorRho(n)
                    k = 0
                    while n % j == 0:
                        n //= j
                        k += 1
                    ret[j] = k

    if n > 1: ret[n] = 1
    if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
    return ret
def sqrt(n):
    x = 1 << (n.bit_length() + 1) // 2
    y = (x + n // x) // 2
    while y < x:
        x = y
        y = (x + n // x) // 2
    return x
def calc(k):
    return (sqrt(8*k+1) - 1) // 2

N  = int(input())
pf = primeFactor(N)
print(sum([calc(pf[p]) for p in pf]))
//  [python]
import sys

N = int(input())
# a,b = map(int,sys.stdin.readline().split())
# arr= list(map(int,sys.stdin.readline().split()))

n= int(1000000000000 ** 0.5)
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
  if a[i]:
    primes.append(i)
    for j in range(2*i, n+1, i):
        a[j] = False
        
ans_dict = {}

# 1일 경우
if N == 1:
    print(0)
    exit()
else:
    i=0
    while N!=1:
        try:
            if N%primes[i] == 0:
                N = N//primes[i]
                if primes[i] in ans_dict:
                    ans_dict[primes[i]] +=1
                else:
                    ans_dict[primes[i]] = 1
            else:
                i+=1
        except:
            print(1)
            exit()
    ans = 0
    for i in ans_dict:
        m = ans_dict[i]
        j = 1
        while m-j >= 0:
            m -= j
            j+=1
            ans+=1
    print(ans)
//  [python]
import sys

N = int(input())
# a,b = map(int,sys.stdin.readline().split())
# arr= list(map(int,sys.stdin.readline().split()))

n= int(1000000000000 ** 0.5)
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
  if a[i]:
    primes.append(i)
    for j in range(2*i, n+1, i):
        a[j] = False
        
ans_dict = {}

# 1일 경우
if N == 1:
    print(0)
    exit()
else:
    i=0
    while N>1:
        if N%primes[i] == 0:
            N = N//primes[i]
            if primes[i] in ans_dict:
                ans_dict[primes[i]] +=1
            else:
                ans_dict[primes[i]] = 1
        else:
            i+=1
    ans = 0
    for i in ans_dict:
        m = ans_dict[i]
        j = 1
        while m-j >= 0:
            m -= j
            j+=1
            ans+=1
    print(ans)
//  [python]
import sys

N = int(input())
# a,b = map(int,sys.stdin.readline().split())
# arr= list(map(int,sys.stdin.readline().split()))

n= int(N ** 0.5)
a = [False,False] + [True]*(n-1)
primes=[]

for i in range(2,n+1):
  if a[i]:
    primes.append(i)
    for j in range(2*i, n+1, i):
        a[j] = False
        
ans_dict = {}

# 1일 경우
if N == 1:
    print(0)
    exit()
else:
    i=0
    while N!=1:
        try:
            if N%primes[i] == 0:
                N = N//primes[i]
                if primes[i] in ans_dict:
                    ans_dict[primes[i]] +=1
                else:
                    ans_dict[primes[i]] = 1
            else:
                i+=1
        except:
            print(1)
            exit()
    ans = 0
    for i in ans_dict:
        m = ans_dict[i]
        j = 1
        while m-j >= 0:
            m -= j
            j+=1
            ans+=1
    print(ans)
//  [java]
import java.util.*;
import java.io.*;

public class Main {	
	static List<Long> pfs;
	static List<Integer> pfcnts;
	private static void solve(){
		//Implement solution here.
		pfs = new ArrayList<Long>();
		pfcnts = new ArrayList<Integer>();
		long N = nl();
		primeFactorization(N);
		//System.out.println(Math.sqrt(N));
//		for(long i:pfs)System.out.print(i + ";");
//		System.out.println();
//		for(long i:pfcnts)System.out.print(i + ";");
//		System.out.println();
		int result = 0;
		for(int i = 0; i < pfcnts.size(); i++) {
			int a = pfcnts.get(i);
			int cmd = 1;
			while(a >= cmd) {
				a -= cmd;
				cmd++;
				result++;
			}
		}
		System.out.println(result);
	}

	/**
	 * Get prime factors list
	 * @param a: Target number to find prime factors
	 * @return List of prime factors
	 */
	static void primeFactorization(long a){
		//pfs.add(1L);
		for(int i = 2; i <= Math.sqrt(a) + 1; i++) {
			
			if(a % i == 0) {
				int cnt = 0;
				pfs.add((long)i);
				while(a % i == 0) {
					a /= i;
					cnt++;
				}
				pfcnts.add(cnt);
			}				
		}
		if(a > 1) {
			pfs.add(a);
			pfcnts.add(1);
		}
	}
	//Switch input source (stdin/file)
	private static BufferedReader br;
	public static void main(String[] args){
		br = new BufferedReader(new InputStreamReader(System.in));
		String debugDataPath = System.getenv("DD_PATH");        
		if(debugDataPath != null){
			try{
				br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(debugDataPath))));
			}catch(Exception e){
				throw new RuntimeException(e);
			}
		}
		boolean hasNext = true;
		while(hasNext){
			solve();	
			try{
				br.mark(1);
				if(br.read() > 0){
					br.reset();			
					System.out.println("---");
				} else {
					hasNext = false;
				}
			}catch(Exception e){
				throw new RuntimeException(e);
			} 
		}
	}

	//Input read utility
	private static StringTokenizer tokenizer = null;
	public static String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}
	//Get next single int
	private static int ni() {
		return Integer.parseInt(next());
	}
	//Get next single long
	private static long nl() {
		return Long.parseLong(next());
	}
	//Get next single double
	private static double nd() {
		return Double.parseDouble(next());
	}
	//Get next int array from one line
	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}
	//Get next char array from one line
	private static char[] ns() {
		return next().toCharArray();
	}
	//Get next long array from one line
	private static long[] nal(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}
}
//  [java]
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;


public class Main {
	
	public static class FastReader {
		BufferedReader br;
		StringTokenizer root;
		
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (root == null || !root.hasMoreTokens()) {
				try {
					root = new StringTokenizer(br.readLine());
				} catch (Exception addd) {
					addd.printStackTrace();
				}
			}
			return root.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception addd) {
				addd.printStackTrace();
			}
			return str;
		}
	}
	
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	
	public static FastReader sc = new FastReader();
 
	static long mod = (int) (1e9+7),MAX=(long)(1e18);
	static List<Integer>[] edges;
	public static int[][] parent;
	public static int col = 20;
	public static void main(String[] args) throws IOException{
		long n = sc.nextLong();
		Map<Long,Integer> map = new HashMap<>();
		fac(n,map);
		//out.print(map);
		long ans = 0;
		for(long key : map.keySet()) {
			long num = 1;
			long val = map.get(key);
			int cnt = 0;
			while(val >= 0) {
			     val-=num;
			     ++num;
			   //  out.println(val);
			     if(val >= 0)
				++cnt;
			}
			//out.println(cnt);
			ans+=cnt;
		}
		out.print(ans);
		out.close();
	}
	
    public static void fac(long n, Map<Long, Integer> map) 
    { 
        // Print the number of 2s that divide n 
        while (n%2==0) 
        {   map.put(2L, map.getOrDefault(2L,0)+1);
       // out.print(map);
            n /= 2; 
        } 
  
        // n must be odd at this point.  So we can 
        // skip one element (Note i = i +2) 
        for (long i = 3; i <= Math.sqrt(n); i+= 2) 
        { 
            // While i divides n, print i and divide n 
            while (n%i == 0) 
            { 
            	map.put(i, map.getOrDefault(i,0)+1);
                n /= i; 
            } 
        } 
  
        // This condition is to handle the case whien 
        // n is a prime number greater than 2 
        if (n > 2) 
        	map.put(n, map.getOrDefault(n,0)+1);
    } 
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std ;

// Template START
#define endl "\n"
#define async ios_base::sync_with_stdio(false); cin.tie(NULL);
#define int long long int
#define all(y) y.begin(), y.end()
#define present( x, y ) (x.find( y ) != x.end())
const int mod = (int)1e9 + 7 ;
template<class T>
auto matrix( int r, int c, T v ){
    return vector<vector<T>>( r, vector<T>( c, v ) ) ;
}
template<class T>
auto matrix( int o1, int o2, int o3, T v ){ 
    return vector<vector<vector<T>>>( o1, vector<vector<T>>( o2, vector<T>( o3, v ) ) ) ;
}
#define v vector
int power( int x, int n ){
    if( n == 0 ) return 1 ;
    else if( n & 1 ) return ( x * power( (x*x) % mod, n / 2 ) ) % mod ;
    return power( (x*x) % mod, n / 2 ) % mod ;
}
template<class T> void __print( v<T> &arr ){
    int n = arr.size() ;
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
template<class T> void __print( T arr[], int n ){ 
    cerr << "[ " ;
    for( int i = 0 ; i < n ; i++ ) {
        cerr << arr[i] ;
        if( i != n - 1 ) cerr << ", " ;
    }
    cerr << " ]" << endl ;
}
#define print(x) cerr << "{ " << #x << " : " << x << " } " ;
#define println(x) cerr << "{ " << #x << " : " << x << " }" << endl ;
// Template END
int solve( int n ){
    int cnt = 0 ;
    for( int i = 2 ; i * i <= n ; i++ ){
        if( n % i == 0 ) ++cnt ;
        while( n % i == 0 ){
            n /= i ;
        }
    }
    if( n > 2 ) ++cnt ;
    return cnt ;
}

signed main(){
    int n ; cin >> n ;
    cout << solve(n) << endl ;
    return 0 ;   
}
//  [cpp]
#include <iostream>
#include <cstring>
#include<vector>
#include <algorithm>
#include<cstdlib>
#include<set>
#include<math.h>
#include<map>
#include<unordered_map>
#include<iomanip>
#include<queue>

using namespace std;
using ll = long long;
using ull = unsigned long long;
ll amari = 1000000007;
#define rep(n,x) for(ll i=0;i<n;i++) cin>>x[i];
#define forr(a,b) for(ll i=a;i<b;i++);
ll modpow(ll a, ll n, ll mod)
{
	ll res = 1;
	while (0 < n)
	{
		if (n & 1) res = res * a % mod;
		a = a * a % mod;
		n >>= 1;
	}
	return res;
}
ll gcd(ll x, ll y)
{
	if (x % y == 0) return y;
	else return gcd(y, x % y);
}
// 1or素数だと１を返す
ll prime(ll x)
{
	for (ll i = 2; i * i <= x; i++)
	{
		if (x % i == 0) return 0;
	}
	return 1;
}



int main()
{
	ll n;
	cin >> n;
	ll k = n;
	ll x = sqrt(n);
	vector<ll> a(x+10, 0);

	for (ll i = 2; i < x + 5; i++)
	{
		while (k % i == 0)
		{
			a[i]++;
			k /= i;
		}
	}


	ll ans = 0;
	ll y = 0;
	for (ll i = 0; i < x+5; i++)
	{
		if (a[i] != 0)
		{
			y = 0;
			while (y * (y + 1) <= 2 * a[i])
			{
				y++;
			}
			y--;
			ans += y;
		}
	}
if(prime(n)==1) ans=1;
  if(n==1) ans=0;
	cout << ans << "\n";
  
	return 0;
}
//  [cpp]
#include <iostream>
#include <cstring>
#include<vector>
#include <algorithm>
#include<cstdlib>
#include<set>
#include<math.h>
#include<map>
#include<unordered_map>
#include<iomanip>
#include<queue>

using namespace std;
using ll = long long;
using ull = unsigned long long;
ll amari = 1000000007;
#define rep(n,x) for(ll i=0;i<n;i++) cin>>x[i];
#define forr(a,b) for(ll i=a;i<b;i++);
ll modpow(ll a, ll n, ll mod)
{
	ll res = 1;
	while (0 < n)
	{
		if (n & 1) res = res * a % mod;
		a = a * a % mod;
		n >>= 1;
	}
	return res;
}
ll gcd(ll x, ll y)
{
	if (x % y == 0) return y;
	else return gcd(y, x % y);
}
// 1or素数だと１を返す
ll prime(ll x)
{
	for (ll i = 2; i * i <= x; i++)
	{
		if (x % i == 0) return 0;
	}
	return 1;
}



int main()
{
	ll n;
	cin >> n;
	ll k = n;
	ll x = sqrt(n);
	vector<ll> a(x+10, 0);

	for (ll i = 2; i < x + 5; i++)
	{
		while (k % i == 0)
		{
			a[i]++;
			k /= i;
		}
	}


	ll ans = 0;
	ll y = 0;
	for (ll i = 0; i < x+5; i++)
	{
		if (a[i] != 0)
		{
			y = 0;
			while (y * (y + 1) <= 2 * a[i])
			{
				y++;
			}
			y--;
			ans += y;
		}
	}
	if (n == 1) ans = 0;

	cout << ans << "\n";
  
	return 0;
}
//  [c]
//div game
#include <stdio.h>
#include <math.h>

int main(void){
    unsigned long int n;
    unsigned long int sq_n;
    unsigned int i=2;
    unsigned long int cnt = 0;
    unsigned long int div;
    
    scanf("%lu",&n);
    sq_n = sqrt(n);

    if(n%i==0) {//i=2
        div = i;
        while(n%div==0){
            n/= div;
            div *= i;
            cnt ++;
        }
        while(n%i == 0) n/=i;
    }

    for(i = 3;i<=sq_n;i+=2){
        if(n%i==0) {
            div = i;
            while(n%div==0){
                n/= div;
                div *= i;
                cnt ++;
            }
            while(n%i == 0) n/=i;
        }
    }
    if(n != 1) cnt ++;
    printf("%lu",cnt);

    return 0;
}
//  [c]
//div game
#include <stdio.h>
#include <math.h>

int main(void){
    unsigned long int n;

    scanf("%lu",&n);

    unsigned int i=2;
    unsigned long int cnt = 0;

    if(n%i==0) {
        unsigned long int div = i;
        for(unsigned int j = 1;n%(int)pow(div,j)==0;j++){
            n/= pow(div,j);
            cnt ++;
        }
        while(n%div == 0) n/=div;
    }

    for(i = 3;i<sqrt(n);i+=2){
        if(n%i==0) {
            unsigned long int div = i;
            for(unsigned int j = 1;n%(int)pow(div,j)==0;j++){
                n/= pow(div,j);
                cnt ++;
            }
            while(n%div == 0) n/=div;
        }
    }
    if(n>sqrt(n)) cnt ++;
    printf("%lu",cnt);

    return 0;
}
//  [c]
#include <float.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <math.h>
#ifdef __cplusplus
#include <bits/stdc++.h>
#endif

int32_t nextint(void){ char c=getchar_unlocked(); while(c!='-'&&(c<'0'||'9'<c)) c=getchar_unlocked(); bool s=false; if(c=='-'){s=true;c=getchar_unlocked();} uint32_t x=0; while('0'<=c && c<='9'){ x=x*10+c-'0'; c=getchar_unlocked(); } return s?-x:x; }
int64_t nextlong(void){ char c=getchar_unlocked(); while(c!='-'&&(c<'0'||'9'<c)) c=getchar_unlocked(); int s=0; if(c=='-'){s=1;c=getchar_unlocked();} uint64_t x=0; while('0'<=c && c<='9'){ x=x*10+c-'0'; c=getchar_unlocked(); } return s?-x:x; }

int a[40]={0,1,1,2,2,2,3,3,3,3,4,4,4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,8,8,8,8};
int main(void){
	long n=nextlong();
	int ans=0;
	{int i=2; int b=0; while(n%i==0){ n/=i; b++; } ans+=a[b];}
	{int i=3; int b=0; while(n%i==0){ n/=i; b++; } ans+=a[b];}
	{int i=5; int b=0; while(n%i==0){ n/=i; b++; } ans+=a[b];}
	int m=sqrt(n);
	for(int i=7; i<m;){
		{int b=0; while(n%i==0){ n/=i; b++; } ans+=a[b];}
		i+=4;
		{int b=0; while(n%i==0){ n/=i; b++; } ans+=a[b];}
		i+=2;
	}
	printf("%d\n", ans+(n>1));
}
//  [c]
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
int main()
{
    map<int,int> m;
    long long int n;
    cin>>n;
    for(int i=2;i<=sqrt(n);i++)
    {
        while(n%i==0)
        {
            m[i]++;
            n=n/i;
        }
    }
    if(n>1)
    m[n]++;
    int ans=0;
    for(auto it:m)
    {
        int p=it.second;
        int curr=1;
        while(p>=curr)
        {
            ans++;
            p-=curr;
            curr++;
        }
    }
    cout<<ans<<endl;

}
//  [c]
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
	long long n,ans=0,total,j,i;
	scanf("%lld",&n);
	for(i=2;i<=sqrt(n)||n==1;i++){
		if(n%i==0){
			total=0,j=1;
			while(n%i==0){
				n/=i;
				total++;
			}
			while(total-j>=0){
				total-=j;
				j++;ans++;
			}
		}
	}
	if(n!=1)ans++;
	printf("%lld\n",ans);
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define ll long long

void swap (int *x, int *y) {
  int temp;

  temp = *x;
  *x = *y;
  *y = temp;

  return;
}


int gcd(int a, int b){
  int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

int upll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?-1:*(ll*)a>*(ll*)b?1:0;
}

int downll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?1:*(ll*)a>*(ll*)b?-1:0;
}

void sortup(ll*a,int n){
  qsort(a,n,sizeof(ll),upll);
}

void sortdown(ll*a,int n){
  qsort(a,n,sizeof(ll),downll);
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

int max(int a,int b){
  if(a<b){
    return b;
  }
  else{
    return a;
  }
}

int min(int a,int b){
  if(a<b){
    return a;
  }
  else{
    return b;
  }
}

void chmax(int *a,int b){
  if(*a < b){
    *a = b;
  }

  return;
}

void chmin(int *a,int b){
  if(*a > b){
    *a =b;
  }

  return;
}


/****************************************\
| Thank you for viewing my code:)        |
| Written by RedSpica a.k.a. RanseMirage |
| Twitter:@asakaakasaka                  | 
\****************************************/

int main(void){
  long int n;
  scanf("%ld",&n);
  long int N=n;
  int ans=0;

  for(int i=2;i*i<=N;i++){
    int cnt=0;
    while(n%i==0){
      cnt++;
      n/=i;
    }

    for(int j=1;j<100;j++){
      if(cnt<j*(j+1)/2){
        ans+=j-1;
        break;
      }
    }
  }
  if(n!=1){
    ans++;
  }

  printf("%d\n",ans);

  return 0;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
  n = parseInt(input);
  var priArray = getPrimeFactors(n);
  var summary = [];
  var tmp = 0 ;
  for (let i=0;i<priArray.length;i++){
    if (priArray[i] == tmp){
      summary[summary.length - 1] ++;
    }else{
      summary.push(1);
      tmp = priArray[i];
    }
  }
  var sum = 0
  for (let i=0;i<summary.length;i++){
    var ok = 1;
    var cnt = 1;
    while (ok === 1){
      if (cnt * (cnt+1) / 2 > summary[i]){
        ok = 0;
        sum += cnt -1;
      }else{
        cnt ++;
      }
    }
  }
  console.log(sum);
}
  
const getPrimeFactors = n => {
  if (n < 2) return [];
  if (n === 2 || n === 3 || n === 5) return [n];
  if (n % 2 === 0) return [2, ...getPrimeFactors(n/2)];
  if (n % 3 === 0) return [3, ...getPrimeFactors(n/3)];
  if (n % 5 === 0) return [5, ...getPrimeFactors(n/5)];
  let prime = 7;
  let step = 4;
  const limit = Math.sqrt(n);
  while (prime <= limit) {
    if (n % prime === 0) return [prime, ...getPrimeFactors(n/prime)];
    prime += step;
    step = 6 - step;
  }
  return [n];
}

Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
const input = require("fs").readFileSync("/dev/stdin", "utf8")
const N = parseInt(input, 10)

let c = 0
let n = N
for (let i = 2; i * i < n; i++) {
    let _i = i
    while (n % _i === 0) {
        n /= _i
        c++
        _i = _i * i
    }
    while (n % i === 0) {
        n /= i
    }
}

if (n > 1) {
    c++
}
console.log(c)
//  [javascript]
"use strict";
var input=require("fs").readFileSync("/dev/stdin","utf8");
var cin=input.split(/ |\n/),cid=0;
function next(){return +cin[cid++];}
function nextstr(){return cin[cid++];}
function nextbig(){return BigInt(cin[cid++]);}
function nexts(n,a){return a?cin.slice(cid,cid+=n):cin.slice(cid,cid+=n).map(a=>+a);}
function nextm(h,w,a){var r=[],i=0;if(a)for(;i<h;i++)r.push(cin.slice(cid,cid+=w));else for(;i<h;i++)r.push(cin.slice(cid,cid+=w).map(a=>+a));return r;}
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill().map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill().map(x=>"+r+")";return eval(r);}

var myOut = main();
if(myOut !== undefined)console.log(myOut);

function main(){
  var n = next();
  var map = {};
  var k = n;
  for(var i = 2; i*i <= k; i++){
    if(k % i === 0){
      map[i] = 0;
      while(k % i === 0)map[i]++,k /= i;
    }
  }
  if(k > 1)map[k] = 1;
  var a = [];
  for(var i in map)a.push(map[i]);
  var ans = 0;
  a.sort((a,b) => b-a);
  for(var i = 0; i < a.length; i++){
    for(var j = 1; j <= a[i]; j++){
      ans++;
      a[i] -= j;
    }
  }
  return ans;
}
//  [javascript]
function Main(input){
    input=input.split("\n");  //ここまで必須
    var result=0;
    var num=input[0];
    for (i=2;i<parseInt(input[0])+1;i++){
       if (parseInt(num)%parseInt(i)==0){
           result=result+1;
           num=parseInt(num)/parseInt(i)
       } 
    }
    console.log(result)
}
Main(require("fs").readFileSync("/dev/stdin","utf8"));
//  [javascript]
function Main(input) {
	input = input.trim();
	var N = parseInt(input, 10);
	var vec_p = [];
	var vec_e = [];
	var tmpN = N;
	var j = 0;
	var k = 0;
	var ans = 0;
	var checkTmpN = 1;
	var tmp;
	for (var i = 2; i <= Math.sqrt(N); i++){
		j = 0;
		same_number:
		while (true) {
			if (tmpN % i === 0){
				j ++;
				tmpN = tmpN / i ;
				checkTmpN *= i;
				if (j === 1) {
					vec_p.push(i);
					vec_e.push(1);
					k++;
				} else {
					vec_e[k - 1] ++;
				}
			} else {
				break same_number;
			}
		}
	}
	if (checkTmpN !== N) {
		vec_p.push(N / checkTmpN);
		vec_e.push(1);
	}
	for (var i = 0; i < vec_e.length; i++){
		tmp = Math.floor((Math.sqrt(1 + (8 * vec_e[i])) - 1) / 2);
		ans += tmp;
	}
 	console.log(ans,vec_p,vec_e);	
}   

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.trim().split(" ");
	var N = parseInt(input, 10);
	var vec_p = [];
	var vec_e = [];
	var tmpN = N;
	var j = 0;
	var k = 0;
	var  ans = 0;
	var tmp;
	for (var i = 2; i <= Math.sqrt(N); i++){
		j = 0;
		same_number:
		while (true) {
			if (tmpN % i === 0){
				j ++;
				tmpN = tmpN / i ;
				if (j === 1) {
					vec_p.push(i);
					vec_e.push(1);
					k++;
				} else {
					vec_e[k - 1] ++;
				}
			} else {
				break same_number;
			}
		}
	}
	for (var i = 0; i < vec_e.length; i++){
		tmp = Math.floor((Math.sqrt(1 + (8 * vec_e[i])) - 1) / 2);
		ans += tmp;
	}
  	if ((N !== 1) && (ans === 0)) ans = 1;
 	console.log(ans);	
}   

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
)

var MaxN int

func main() {
	sc := NewScanner()

	MaxN = Pow(10, 12)

	n := sc.ReadInt()

	ans := 0
	primeCounts := PrimeFactorize(n)
	for _, count := range primeCounts {
		ans += f(count)
	}

	fmt.Println(ans)
}

func f(n int) int {
	switch {
	case n < 1:
		return 0
	case n < 3:
		return 1
	case n < 6:
		return 2
	case n < 10:
		return 3
	case n < 15:
		return 4
	case n < 21:
		return 5
	case n < 28:
		return 6
	case n < 36:
		return 7
	case n < 45:
		return 8
	}
	return -1
}

func PrimeFactorize(n int) map[int]int {
	primeCounts := make(map[int]int)

	sqrtMax := int(math.Sqrt(float64(MaxN)))

	for n%2 == 0 {
		primeCounts[2]++
		n /= 2
	}
	for n%3 == 0 {
		primeCounts[3]++
		n /= 3
	}

	flag := true
	for i := 5; n > 1 && i <= sqrtMax; {
		for n%i == 0 {
			primeCounts[i]++
			n /= i
		}

		if flag {
			i += 2
		} else {
			i += 4
		}
		flag = !flag
	}

	if n > 1 {
		primeCounts[n]++
	}

	return primeCounts
}

// util
// *   math/simple

func Abs(x int) int {
	if x >= 0 {
		return x
	}
	return -x
}

func Min(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}
	min := values[0]
	for _, v := range values {
		if v < min {
			min = v
		}
	}
	return min
}

func Max(values ...int) int {
	if len(values) == 0 {
		panic("no values")
	}
	max := values[0]
	for _, v := range values {
		if v > max {
			max = v
		}
	}
	return max
}

func Pow(base int, exponent uint) int {
	answer := 1
	for i := uint(0); i < exponent; i++ {
		answer *= base
	}
	return answer
}

func Ceil(divident, dividor int) int {
	quo := divident / dividor
	rem := divident % dividor

	if rem != 0 {
		if (divident > 0 && dividor > 0) ||
			(divident < 0 && dividor < 0) {
			return quo + 1
		}
	}
	return quo
}

// *   sortutil

func ReverseInts(a []int) {
	sort.Sort(sort.Reverse(sort.IntSlice(a)))
}

func ReverseStrings(a []string) {
	sort.Sort(sort.Reverse(sort.StringSlice(a)))
}

// *   io

type Scanner struct {
	bufScanner *bufio.Scanner
}

func NewScanner() *Scanner {
	bufSc := bufio.NewScanner(os.Stdin)
	bufSc.Split(bufio.ScanWords)
	bufSc.Buffer(nil, 100000000)
	return &Scanner{bufSc}
}

func (sc *Scanner) ReadString() string {
	bufSc := sc.bufScanner
	bufSc.Scan()
	return bufSc.Text()
}

func (sc *Scanner) ReadInt() int {
	bufSc := sc.bufScanner
	bufSc.Scan()
	text := bufSc.Text()

	num, err := strconv.Atoi(text)
	if err != nil {
		panic(err)
	}
	return num
}

func (sc *Scanner) ReadFloat() float64 {
	bufSc := sc.bufScanner
	bufSc.Scan()
	text := bufSc.Text()

	num, err := strconv.ParseFloat(text, 64)
	if err != nil {
		panic(err)
	}
	return num
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)

	count := 0
	for _, cnt := range PrimeFactorize(n) {
		for i := 1; i <= cnt; i++ {
			count++
			cnt -= i
		}
	}

	fmt.Println(count)
}

// generated by https://github.com/murosan/gollect

func PrimeFactorize(n int) map[int]int {
	m := make(map[int]int)
	for n%2 == 0 {
		m[2]++
		n /= 2
	}
	for i := 3; i*i <= n; i += 2 {
		for n%i == 0 {
			m[i]++
			n /= i
		}
	}
	if n != 1 {
		m[n]++
	}
	return m
}
//  [go]
package main

import "fmt"

func main() {
	var n int
	fmt.Scanf("%d", &n)

	factors := factorize(n)
	count := 0
	for _, pair := range factors {
		i := 1
		for pair[1] >= i {
			pair[1] -= i
			i++
			count++
		}
	}

	fmt.Printf("%d\n", count)
}

func factorize(n int) [][]int {
	tmp := n
	factors := [][]int{}
	for f := 2; f*f <= n; f++ {
		i := 0
		for tmp%f == 0 {
			i++
			tmp /= f
		}
		if i > 0 {
			factors = append(factors, []int{f, i})
		}
	}
	if n > 1 && len(factors) == 0 {
		factors = append(factors, []int{n, 1})
	}
	return factors
}
//  [go]
package main

import "fmt"

func main() {
	var n int64
	fmt.Scan(&n)
	m := make(map[int64]bool)
	for i := int64(2); i*i <= n; i++ {
		if n%i == 0 && !m[i] {
			n /= i
			m[i] = true
		}
	}
	if n != 1 && !m[n] {
		m[n] = true
	}
	fmt.Println(len(m))
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
)

func main() {
	scanner := NewScanner()
	n := scanner.NextInt64()
	if n == 1 {
		fmt.Println(0)
		return
	}
	r := 1
	for ; int64(r*r) <= n; r++ {
	}
	ms := make([]bool, r)
	count := 0
	for i := 2; i < len(ms); i++ {
		if ms[i] {
			continue
		}
		for j := 1; i*j < len(ms); j++ {
			ms[i*j] = true
		}
		for j := i; j < len(ms); j *= i {
			if n%int64(j) == 0 {
				n /= int64(j)
				count++
			}
		}
	}
	if count == 0 {
		// Nは素数
		fmt.Println(1)
	} else {
		fmt.Println(count)
	}
}

type Scanner struct {
	scanner *bufio.Scanner
}

func NewScanner() *Scanner {
	s := bufio.NewScanner(os.Stdin)
	s.Split(bufio.ScanWords)
	return &Scanner{s}
}

func (s *Scanner) NextWord() string {
	if !s.scanner.Scan() {
		log.Fatal("failed to find the next word")
	}
	return s.scanner.Text()
}

func (s *Scanner) NextInt() int {
	str := s.NextWord()
	i, err := strconv.Atoi(str)
	if err != nil {
		log.Fatalf("failed to parse %s to int", str)
	}
	return i
}

func (s *Scanner) NextInt64() int64 {
	str := s.NextWord()
	i, err := strconv.ParseInt(str, 10, 64)
	if err != nil {
		log.Fatalf("failed to parse %s to int64", str)
	}
	return i
}
//  [ruby]
p`factor`.split.tally.sum{((8*_2+1)**0.5-1).to_i/2}-1
//  [ruby]
p`factor`.split.tally.sum{|_,v|(0..).find{0>v+=~_1}}-1
//  [ruby]
p~`factor`.split.tally.sum{1-((2*_2+2)**0.5).round}
//  [ruby]
require "prime"
#input of int(split by space)
def get_i()
  return gets.chomp.split(" ").map(&:to_i)
end
#input of float(split by space)
def get_f()
  return gets.chomp.split(" ").map(&:to_f)
end
#input of string(split by space)
def get()
  return gets.chomp.split(" ")
end
#input of string(split per one character)
def get_nsp()
  return gets.chomp.split("")
end
#yes or no decision
def yn_judge(bool,y="Yes",n="No")
  return bool ? y : n 
end
#create of array
def array(size1,init=nil,size2=-1)
  if size2==-1
      return Array.new(size1){init}
  else
      return Array.new(size2){Array.new(size1){init}}
  end
end

def max(a,b)
    return a>b ? a : b
end

def min(a,b)
    return a>b ? b : a
end

INF=Float::INFINITY

N=gets.to_i
if N==1
    puts 0
    exit
elsif Prime.prime?(N)
    puts 1
    exit
end
n=N
table=Hash.new(false)
table[1]=true
ans=0
2.upto((N**0.5).to_i) do|i|
  k=i
  while not table[k] and (n%k).zero?
    n/=k
    table[k]=true
    k*=i
    ans+=1
  end
end
puts ans